/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (https://www.swig.org).
 * Version 4.4.1
 *
 * Do not make changes to this file unless you know what you are doing - modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */


#define SWIG_VERSION 0x040401
#define SWIGJAVA
#define SWIG_DIRECTORS

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__))
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__))
# else
#   define SWIGUNUSED
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if defined(__GNUC__)
#  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#    ifndef GCC_HASCLASSVISIBILITY
#      define GCC_HASCLASSVISIBILITY
#    endif
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif

/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
#endif

/* Intel's compiler complains if a variable which was never initialised is
 * cast to void, which is a common idiom which we use to indicate that we
 * are aware a variable isn't used.  So we just silence that warning.
 * See: https://github.com/swig/swig/issues/192 for more discussion.
 */
#ifdef __INTEL_COMPILER
# pragma warning disable 592
#endif

#if defined(__cplusplus) && __cplusplus >=201103L
# define SWIG_NOEXCEPT noexcept
#else
# define SWIG_NOEXCEPT throw()
#endif 

/* -----------------------------------------------------------------------------
 * swigcompat.swg
 *
 * Macros to provide support compatibility with older C and C++ standards.
 *
 * Note that SWIG expects __cplusplus to be defined to the appropriate C++ standard.
 * MSVC users are urged to check and examine the /Zc:__cplusplus compiler option.
 * See https://learn.microsoft.com/en-us/cpp/build/reference/zc-cplusplus.
 * ----------------------------------------------------------------------------- */

/* C99 and C++11 should provide snprintf, but define SWIG_NO_SNPRINTF
 * if you're missing it.
 */
#if ((defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L) || \
     (defined __cplusplus && __cplusplus >= 201103L) || \
     defined SWIG_HAVE_SNPRINTF) && \
    !defined SWIG_NO_SNPRINTF
# define SWIG_snprintf(O,S,F,A) snprintf(O,S,F,A)
# define SWIG_snprintf2(O,S,F,A,B) snprintf(O,S,F,A,B)
#else
/* Fallback versions ignore the buffer size, but most of our uses either have a
 * fixed maximum possible size or dynamically allocate a buffer that's large
 * enough.
 */
# define SWIG_snprintf(O,S,F,A) sprintf(O,F,A)
# define SWIG_snprintf2(O,S,F,A,B) sprintf(O,F,A,B)
#endif


#include <jni.h>
#include <stdlib.h>
#include <string.h>


/* Support for throwing Java exceptions */
typedef enum {
  SWIG_JavaOutOfMemoryError = 1,
  SWIG_JavaIOException,
  SWIG_JavaRuntimeException,
  SWIG_JavaIndexOutOfBoundsException,
  SWIG_JavaArithmeticException,
  SWIG_JavaIllegalArgumentException,
  SWIG_JavaNullPointerException,
  SWIG_JavaDirectorPureVirtual,
  SWIG_JavaUnknownError,
  SWIG_JavaIllegalStateException,
} SWIG_JavaExceptionCodes;

typedef struct {
  SWIG_JavaExceptionCodes code;
  const char *java_exception;
} SWIG_JavaExceptions_t;


static void SWIGUNUSED SWIG_JavaThrowException(JNIEnv *jenv, SWIG_JavaExceptionCodes code, const char *msg) {
  jclass excep;
  static const SWIG_JavaExceptions_t java_exceptions[] = {
    { SWIG_JavaOutOfMemoryError, "java/lang/OutOfMemoryError" },
    { SWIG_JavaIOException, "java/io/IOException" },
    { SWIG_JavaRuntimeException, "java/lang/RuntimeException" },
    { SWIG_JavaIndexOutOfBoundsException, "java/lang/IndexOutOfBoundsException" },
    { SWIG_JavaArithmeticException, "java/lang/ArithmeticException" },
    { SWIG_JavaIllegalArgumentException, "java/lang/IllegalArgumentException" },
    { SWIG_JavaNullPointerException, "java/lang/NullPointerException" },
    { SWIG_JavaDirectorPureVirtual, "java/lang/RuntimeException" },
    { SWIG_JavaUnknownError,  "java/lang/UnknownError" },
    { SWIG_JavaIllegalStateException, "java/lang/IllegalStateException" },
    { (SWIG_JavaExceptionCodes)0,  "java/lang/UnknownError" }
  };
  const SWIG_JavaExceptions_t *except_ptr = java_exceptions;

  while (except_ptr->code != code && except_ptr->code)
    except_ptr++;

  jenv->ExceptionClear();
  excep = jenv->FindClass(except_ptr->java_exception);
  if (excep)
    jenv->ThrowNew(excep, msg);
}


/* Contract support */

#define SWIG_contract_assert(nullreturn, expr, msg) do { if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } } while (0)

/* SWIG Errors applicable to all language modules, values are reserved from -1 to -99 */
#define  SWIG_UnknownError    	   -1
#define  SWIG_IOError        	   -2
#define  SWIG_RuntimeError   	   -3
#define  SWIG_IndexError     	   -4
#define  SWIG_TypeError      	   -5
#define  SWIG_DivisionByZero 	   -6
#define  SWIG_OverflowError  	   -7
#define  SWIG_SyntaxError    	   -8
#define  SWIG_ValueError     	   -9
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12
#define  SWIG_NullReferenceError   -13


/* -----------------------------------------------------------------------------
 * director_common.swg
 *
 * This file contains support for director classes which is common between
 * languages.
 * ----------------------------------------------------------------------------- */

/*
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
  'Swig' namespace. This could be useful for multi-modules projects.
*/
#ifdef SWIG_DIRECTOR_STATIC
/* Force anonymous (static) namespace */
#define Swig
#endif
/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that Java proxy
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#if defined(DEBUG_DIRECTOR_OWNED) || defined(DEBUG_DIRECTOR_EXCEPTION) || defined(DEBUG_DIRECTOR_THREAD_NAME)
#include <iostream>
#endif

#include <exception>

#if defined(SWIG_JAVA_USE_THREAD_NAME)

#if !defined(SWIG_JAVA_GET_THREAD_NAME)
namespace Swig {
  SWIGINTERN int GetThreadName(char *name, size_t len);
}

#if defined(__linux__)

#include <sys/prctl.h>
SWIGINTERN int Swig::GetThreadName(char *name, size_t len) {
  (void)len;
#if defined(PR_GET_NAME)
  return prctl(PR_GET_NAME, (unsigned long)name, 0, 0, 0);
#else
  (void)name;
  return 1;
#endif
}

#elif defined(__unix__) || defined(__APPLE__)

#include <pthread.h>
SWIGINTERN int Swig::GetThreadName(char *name, size_t len) {
  return pthread_getname_np(pthread_self(), name, len);
}

#else

SWIGINTERN int Swig::GetThreadName(char *name, size_t len) {
  (void)len;
  (void)name;
  return 1;
}
#endif

#endif

#endif

#if defined(SWIG_JAVA_DETACH_ON_THREAD_END)
#include <pthread.h>
#endif

namespace Swig {

  /* Java object wrapper */
  class JObjectWrapper {
  public:
    JObjectWrapper() : jthis_(NULL), weak_global_(true) {
    }

    ~JObjectWrapper() {
      jthis_ = NULL;
      weak_global_ = true;
    }

    bool set(JNIEnv *jenv, jobject jobj, bool mem_own, bool weak_global) {
      if (!jthis_) {
        weak_global_ = weak_global || !mem_own; // hold as weak global if explicitly requested or not owned
        if (jobj)
          jthis_ = weak_global_ ? jenv->NewWeakGlobalRef(jobj) : jenv->NewGlobalRef(jobj);
#if defined(DEBUG_DIRECTOR_OWNED)
        std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> " << jthis_ << std::endl;
#endif
        return true;
      } else {
#if defined(DEBUG_DIRECTOR_OWNED)
        std::cout << "JObjectWrapper::set(" << jobj << ", " << (weak_global ? "weak_global" : "global_ref") << ") -> already set" << std::endl;
#endif
        return false;
      }
    }

    jobject get(JNIEnv *jenv) const {
#if defined(DEBUG_DIRECTOR_OWNED)
      std::cout << "JObjectWrapper::get(";
      if (jthis_)
        std::cout << jthis_;
      else
        std::cout << "null";
      std::cout << ") -> return new local ref" << std::endl;
#endif
      return (jthis_ ? jenv->NewLocalRef(jthis_) : jthis_);
    }

    void release(JNIEnv *jenv) {
#if defined(DEBUG_DIRECTOR_OWNED)
      std::cout << "JObjectWrapper::release(" << jthis_ << "): " << (weak_global_ ? "weak global ref" : "global ref") << std::endl;
#endif
      if (jthis_) {
        if (weak_global_) {
          if (jenv->IsSameObject(jthis_, NULL) == JNI_FALSE)
            jenv->DeleteWeakGlobalRef((jweak)jthis_);
        } else
          jenv->DeleteGlobalRef(jthis_);
      }

      jthis_ = NULL;
      weak_global_ = true;
    }

    /* Only call peek if you know what you are doing wrt to weak/global references */
    jobject peek() {
      return jthis_;
    }

    /* Java proxy releases ownership of C++ object, C++ object is now
       responsible for destruction (creates NewGlobalRef to pin Java proxy) */
    void java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
      if (take_or_release) {  /* Java takes ownership of C++ object's lifetime. */
        if (!weak_global_) {
          jenv->DeleteGlobalRef(jthis_);
          jthis_ = jenv->NewWeakGlobalRef(jself);
          weak_global_ = true;
        }
      } else {
	/* Java releases ownership of C++ object's lifetime */
        if (weak_global_) {
          jenv->DeleteWeakGlobalRef((jweak)jthis_);
          jthis_ = jenv->NewGlobalRef(jself);
          weak_global_ = false;
        }
      }
    }

#if defined(SWIG_JAVA_DETACH_ON_THREAD_END)
    static void detach(void *jvm) {
      static_cast<JavaVM *>(jvm)->DetachCurrentThread();
    }

    static void make_detach_key() {
      pthread_key_create(&detach_key_, detach);
    }

    /* thread-local key to register a destructor */
    static pthread_key_t detach_key_;
#endif

  private:
    /* pointer to Java object */
    jobject jthis_;
    /* Local or global reference flag */
    bool weak_global_;
  };

#if defined(SWIG_JAVA_DETACH_ON_THREAD_END)
  pthread_key_t JObjectWrapper::detach_key_;
#endif

  /* Local JNI reference deleter */
  class LocalRefGuard {
    JNIEnv *jenv_;
    jobject jobj_;

    // non-copyable
    LocalRefGuard(const LocalRefGuard &);
    LocalRefGuard &operator=(const LocalRefGuard &);
  public:
    LocalRefGuard(JNIEnv *jenv, jobject jobj): jenv_(jenv), jobj_(jobj) {}
    ~LocalRefGuard() {
      if (jobj_)
        jenv_->DeleteLocalRef(jobj_);
    }
  };

  /* director base class */
  class Director {
    /* pointer to Java virtual machine */
    JavaVM *swig_jvm_;

  protected:
#if defined (_MSC_VER) && (_MSC_VER<1300)
    class JNIEnvWrapper;
    friend class JNIEnvWrapper;
#endif
    /* Utility class for managing the JNI environment */
    class JNIEnvWrapper {
      const Director *director_;
      JNIEnv *jenv_;
      int env_status;
    public:
      JNIEnvWrapper(const Director *director) : director_(director), jenv_(NULL), env_status(0) {
#if defined(__ANDROID__)
        JNIEnv **jenv = &jenv_;
#else
        void **jenv = (void **)&jenv_;
#endif
        env_status = director_->swig_jvm_->GetEnv((void **)&jenv_, JNI_VERSION_1_2);
        JavaVMAttachArgs args;
        args.version = JNI_VERSION_1_2;
        args.group = NULL;
        args.name = NULL;
#if defined(SWIG_JAVA_USE_THREAD_NAME)
        char thread_name[64];  // MAX_TASK_COMM_LEN=16 is hard-coded in the Linux kernel and MacOS has MAXTHREADNAMESIZE=64.
        if (Swig::GetThreadName(thread_name, sizeof(thread_name)) == 0) {
          args.name = thread_name;
#if defined(DEBUG_DIRECTOR_THREAD_NAME)
          std::cout << "JNIEnvWrapper: thread name: " << thread_name << std::endl;
        } else {
          std::cout << "JNIEnvWrapper: Couldn't set Java thread name" << std::endl;
#endif
        }
#endif
#if defined(SWIG_JAVA_ATTACH_CURRENT_THREAD_AS_DAEMON)
        // Attach a daemon thread to the JVM. Useful when the JVM should not wait for
        // the thread to exit upon shutdown. Only for jdk-1.4 and later.
        director_->swig_jvm_->AttachCurrentThreadAsDaemon(jenv, &args);
#else
        director_->swig_jvm_->AttachCurrentThread(jenv, &args);
#endif

#if defined(SWIG_JAVA_DETACH_ON_THREAD_END)
        // At least on Android 6, detaching after every call causes a memory leak.
        // Instead, register a thread desructor and detach only when the thread ends.
        // See https://developer.android.com/training/articles/perf-jni#threads
        static pthread_once_t once = PTHREAD_ONCE_INIT;

        pthread_once(&once, JObjectWrapper::make_detach_key);
        pthread_setspecific(JObjectWrapper::detach_key_, director->swig_jvm_);
#endif
      }
      ~JNIEnvWrapper() {
#if !defined(SWIG_JAVA_DETACH_ON_THREAD_END) && !defined(SWIG_JAVA_NO_DETACH_CURRENT_THREAD)
        // Some JVMs, eg jdk-1.4.2 and lower on Solaris have a bug and crash with the DetachCurrentThread call.
        // However, without this call, the JVM hangs on exit when the thread was not created by the JVM and creates a memory leak.
        if (env_status == JNI_EDETACHED)
          director_->swig_jvm_->DetachCurrentThread();
#endif
      }
      JNIEnv *getJNIEnv() const {
        return jenv_;
      }
    };

    struct SwigDirectorMethod {
      const char *name;
      const char *desc;
      jmethodID methid;
      SwigDirectorMethod(JNIEnv *jenv, jclass baseclass, const char *name, const char *desc) : name(name), desc(desc) {
        methid = jenv->GetMethodID(baseclass, name, desc);
      }
    };

    /* Java object wrapper */
    JObjectWrapper swig_self_;

    /* Disconnect director from Java object */
    void swig_disconnect_director_self(const char *disconn_method) {
      JNIEnvWrapper jnienv(this) ;
      JNIEnv *jenv = jnienv.getJNIEnv() ;
      jobject jobj = swig_self_.get(jenv);
      LocalRefGuard ref_deleter(jenv, jobj);
#if defined(DEBUG_DIRECTOR_OWNED)
      std::cout << "Swig::Director::disconnect_director_self(" << jobj << ")" << std::endl;
#endif
      if (jobj && jenv->IsSameObject(jobj, NULL) == JNI_FALSE) {
        jmethodID disconn_meth = jenv->GetMethodID(jenv->GetObjectClass(jobj), disconn_method, "()V");
        if (disconn_meth) {
#if defined(DEBUG_DIRECTOR_OWNED)
          std::cout << "Swig::Director::disconnect_director_self upcall to " << disconn_method << std::endl;
#endif
          jenv->CallVoidMethod(jobj, disconn_meth);
        }
      }
    }

    jclass swig_new_global_ref(JNIEnv *jenv, const char *classname) {
      jclass clz = jenv->FindClass(classname);
      return clz ? (jclass)jenv->NewGlobalRef(clz) : NULL;
    }

  public:
    Director(JNIEnv *jenv) : swig_jvm_((JavaVM *) NULL), swig_self_() {
      /* Acquire the Java VM pointer */
      jenv->GetJavaVM(&swig_jvm_);
    }

    virtual ~Director() {
      JNIEnvWrapper jnienv(this) ;
      JNIEnv *jenv = jnienv.getJNIEnv() ;
      swig_self_.release(jenv);
    }

    bool swig_set_self(JNIEnv *jenv, jobject jself, bool mem_own, bool weak_global) {
      return swig_self_.set(jenv, jself, mem_own, weak_global);
    }

    jobject swig_get_self(JNIEnv *jenv) const {
      return swig_self_.get(jenv);
    }

    // Change C++ object's ownership, relative to Java
    void swig_java_change_ownership(JNIEnv *jenv, jobject jself, bool take_or_release) {
      swig_self_.java_change_ownership(jenv, jself, take_or_release);
    }
  };

  // Zero initialized bool array
  template<size_t N> class BoolArray {
    bool array_[N];
  public:
    BoolArray() {
      memset(array_, 0, sizeof(array_));
    }
    bool& operator[](size_t n) {
      return array_[n];
    }
    bool operator[](size_t n) const {
      return array_[n];
    }
  };

  // Utility classes and functions for exception handling.

  // Simple holder for a Java string during exception handling, providing access to a c-style string
  class JavaString {
  public:
    JavaString(JNIEnv *jenv, jstring jstr) : jenv_(jenv), jstr_(jstr), cstr_(NULL) {
      if (jenv_ && jstr_)
	cstr_ = (const char *) jenv_->GetStringUTFChars(jstr_, NULL);
    }

    ~JavaString() {
      if (jenv_ && jstr_ && cstr_)
	jenv_->ReleaseStringUTFChars(jstr_, cstr_);
    }

    const char *c_str(const char *null_string = "null JavaString") const {
      return cstr_ ? cstr_ : null_string;
    }

  private:
    // non-copyable
    JavaString(const JavaString &);
    JavaString &operator=(const JavaString &);

    JNIEnv *jenv_;
    jstring jstr_;
    const char *cstr_;
  };

  // Helper class to extract the exception message from a Java throwable
  class JavaExceptionMessage {
  public:
    JavaExceptionMessage(JNIEnv *jenv, jthrowable throwable) : message_(jenv, exceptionMessageFromThrowable(jenv, throwable)) {
    }

    // Return a C string of the exception message in the jthrowable passed in the constructor
    // If no message is available, null_string is return instead
    const char *message(const char *null_string = "Could not get exception message in JavaExceptionMessage") const {
      return message_.c_str(null_string);
    }

  private:
    // non-copyable
    JavaExceptionMessage(const JavaExceptionMessage &);
    JavaExceptionMessage &operator=(const JavaExceptionMessage &);

    // Get exception message by calling Java method Throwable.getMessage()
    static jstring exceptionMessageFromThrowable(JNIEnv *jenv, jthrowable throwable) {
      jstring jmsg = NULL;
      if (jenv && throwable) {
	jenv->ExceptionClear(); // Cannot invoke methods with any pending exceptions
	jclass throwclz = jenv->GetObjectClass(throwable);
	if (throwclz) {
	  // All Throwable classes have a getMessage() method, so call it to extract the exception message
	  jmethodID getMessageMethodID = jenv->GetMethodID(throwclz, "getMessage", "()Ljava/lang/String;");
	  if (getMessageMethodID)
	    jmsg = (jstring)jenv->CallObjectMethod(throwable, getMessageMethodID);
	}
	if (jmsg == NULL && jenv->ExceptionCheck())
	  jenv->ExceptionClear();
      }
      return jmsg;
    }

    JavaString message_;
  };

  // C++ Exception class for handling Java exceptions thrown during a director method Java upcall
  class DirectorException : public std::exception {
  public:

    // Construct exception from a Java throwable
    DirectorException(JNIEnv *jenv, jthrowable throwable) : jenv_(jenv), throwable_(throwable), classname_(NULL), msg_(NULL) {

      // Call Java method Object.getClass().getName() to obtain the throwable's class name (delimited by '/')
      if (jenv && throwable) {
	jenv->ExceptionClear(); // Cannot invoke methods with any pending exceptions
	jclass throwclz = jenv->GetObjectClass(throwable);
	if (throwclz) {
	  jclass clzclz = jenv->GetObjectClass(throwclz);
	  if (clzclz) {
	    jmethodID getNameMethodID = jenv->GetMethodID(clzclz, "getName", "()Ljava/lang/String;");
	    if (getNameMethodID) {
	      jstring jstr_classname = (jstring)(jenv->CallObjectMethod(throwclz, getNameMethodID));
              // Copy strings, since there is no guarantee that jenv will be active when handled
              if (jstr_classname) {
                JavaString jsclassname(jenv, jstr_classname);
                const char *classname = jsclassname.c_str(NULL);
                if (classname)
                  classname_ = copypath(classname);
              }
	    }
	  }
	}
      }

      JavaExceptionMessage exceptionmsg(jenv, throwable);
      msg_ = copystr(exceptionmsg.message(NULL));
    }

    // More general constructor for handling as a java.lang.RuntimeException
    DirectorException(const char *msg) : jenv_(NULL), throwable_(NULL), classname_(NULL), msg_(msg ? copystr(msg) : NULL) {
    }

    ~DirectorException() SWIG_NOEXCEPT {
      delete[] classname_;
      delete[] msg_;
    }

    const char *what() const SWIG_NOEXCEPT {
      return msg_ ? msg_ : "Unspecified DirectorException message";
    }

    // Reconstruct and raise/throw the Java Exception that caused the DirectorException
    // Note that any error in the JNI exception handling results in a Java RuntimeException
    void throwException(JNIEnv *jenv) const {
      if (jenv) {
        if (jenv == jenv_ && throwable_) {
          // Throw original exception if not already pending
          jthrowable throwable = jenv->ExceptionOccurred();
          if (throwable && jenv->IsSameObject(throwable, throwable_) == JNI_FALSE) {
            jenv->ExceptionClear();
            throwable = NULL;
          }
          if (!throwable)
            jenv->Throw(throwable_);
        } else {
          // Try and reconstruct original exception, but original stacktrace is not reconstructed
          jenv->ExceptionClear();

          jmethodID ctorMethodID = NULL;
          jclass throwableclass = NULL;
          if (classname_) {
            throwableclass = jenv->FindClass(classname_);
            if (throwableclass)
              ctorMethodID = jenv->GetMethodID(throwableclass, "<init>", "(Ljava/lang/String;)V");
          }

          if (ctorMethodID) {
            jenv->ThrowNew(throwableclass, what());
          } else {
            SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, what());
          }
        }
      }
    }

    // Deprecated - use throwException
    void raiseJavaException(JNIEnv *jenv) const {
      throwException(jenv);
    }

    // Create and throw the DirectorException
    static void raise(JNIEnv *jenv, jthrowable throwable) {
      throw DirectorException(jenv, throwable);
    }

  private:
    static char *copypath(const char *srcmsg) {
      char *target = copystr(srcmsg);
      for (char *c=target; *c; ++c) {
        if ('.' == *c)
          *c = '/';
      }
      return target;
    }

    static char *copystr(const char *srcmsg) {
      char *target = NULL;
      if (srcmsg) {
	size_t msglen = strlen(srcmsg) + 1;
	target = new char[msglen];
	strncpy(target, srcmsg, msglen);
      }
      return target;
    }

    JNIEnv *jenv_;
    jthrowable throwable_;
    const char *classname_;
    const char *msg_;
  };

  // Helper method to determine if a Java throwable matches a particular Java class type
  // Note side effect of clearing any pending exceptions
  SWIGINTERN bool ExceptionMatches(JNIEnv *jenv, jthrowable throwable, const char *classname) {
    bool matches = false;

    if (throwable && jenv && classname) {
      // Exceptions need to be cleared for correct behavior.
      // The caller of ExceptionMatches should restore pending exceptions if desired -
      // the caller already has the throwable.
      jenv->ExceptionClear();

      jclass clz = jenv->FindClass(classname);
      if (clz) {
	jclass classclz = jenv->GetObjectClass(clz);
	jmethodID isInstanceMethodID = jenv->GetMethodID(classclz, "isInstance", "(Ljava/lang/Object;)Z");
	if (isInstanceMethodID) {
	  matches = jenv->CallBooleanMethod(clz, isInstanceMethodID, throwable) != 0;
	}
      }

#if defined(DEBUG_DIRECTOR_EXCEPTION)
      if (jenv->ExceptionCheck()) {
        // Typically occurs when an invalid classname argument is passed resulting in a ClassNotFoundException
        JavaExceptionMessage exc(jenv, jenv->ExceptionOccurred());
        std::cout << "Error: ExceptionMatches: class '" << classname << "' : " << exc.message() << std::endl;
      }
#endif
    }
    return matches;
  }
}

namespace Swig {
  namespace {
    jclass jclass_libtorrent_jni = NULL;
    jmethodID director_method_ids[8];
  }
}

#ifdef __cplusplus
#include <utility>
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigSmartPointer {
    T *ptr;
    SwigSmartPointer(T *p) : ptr(p) { }
    ~SwigSmartPointer() { delete ptr; }
    SwigSmartPointer& operator=(SwigSmartPointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
    void reset(T *p) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = p; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigSmartPointer tmp(new T(t)); pointer = tmp; return *this; }
#if __cplusplus >=201103L
  SwigValueWrapper& operator=(T&& t) { SwigSmartPointer tmp(new T(std::move(t))); pointer = tmp; return *this; }
  operator T&&() const { return std::move(*pointer.ptr); }
#else
  operator T&() const { return *pointer.ptr; }
#endif
  T *operator&() const { return pointer.ptr; }
  static void reset(SwigValueWrapper& t, T *p) { t.pointer.reset(p); }
};

/*
 * SwigValueInit() is a generic initialisation solution as the following approach:
 * 
 *       T c_result = T();
 * 
 * doesn't compile for all types for example:
 * 
 *       unsigned int c_result = unsigned int();
 */
template <typename T> T SwigValueInit() {
  return T();
}

#if __cplusplus >=201103L
# define SWIG_STD_MOVE(OBJ) std::move(OBJ)
#else
# define SWIG_STD_MOVE(OBJ) OBJ
#endif

#endif

#if defined(__cplusplus) && (__cplusplus >=201103L)
# define SWIG_OVERRIDE override
#else
# define SWIG_OVERRIDE
#endif



#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_directBufferAddress(JNIEnv *jenv, jclass jcls, jobject jbuf) {
    try {
        return reinterpret_cast<jlong>(jenv->GetDirectBufferAddress(jbuf));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
    }

    return 0;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_directBufferCapacity(JNIEnv *jenv, jclass jcls, jobject jbuf) {
    try {
        return reinterpret_cast<jlong>(jenv->GetDirectBufferCapacity(jbuf));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
    }

    return 0;
}

#ifdef __cplusplus
}
#endif


// BEGIN common set include (just include but don't wrap)----------------------------------------------
#include <boost/container/map.hpp>
#include <libtorrent/flags.hpp>
#include <libtorrent/torrent_handle.hpp>
#include <libtorrent/address.hpp>
#include <libtorrent/socket.hpp>
#include <libtorrent/kademlia/dht_state.hpp>
#include <libtorrent/client_data.hpp>
#include <libtorrent/sha1_hash.hpp>
#include <libtorrent/info_hash.hpp>
#include <libtorrent/storage_defs.hpp>
#include <libtorrent/bitfield.hpp>
#include <libtorrent/operations.hpp>
#include <libtorrent/error_code.hpp>
#include <libtorrent/announce_entry.hpp>
#include <libtorrent/file_storage.hpp>
#include <libtorrent/peer_request.hpp>
#include <libtorrent/bdecode.hpp>
#include <libtorrent/torrent_info.hpp>
#include <libtorrent/torrent_flags.hpp>
#include <libtorrent/add_torrent_params.hpp>
#include <libtorrent/close_reason.hpp>
#include <libtorrent/peer_info.hpp>
#include <libtorrent/pex_flags.hpp>
#include <libtorrent/torrent_status.hpp>
#include <libtorrent/performance_counters.hpp>
#include <libtorrent/portmap.hpp>
#include <libtorrent/piece_block.hpp>
#include <libtorrent/socket_type.hpp>
#include <libtorrent/entry.hpp>
//#include <libtorrent/tracker_event.hpp> // this exists on the 'master' branch
// enum class event_t is defined in tracker_manager.hpp on the 2.0 branch
#include <libtorrent/tracker_manager.hpp>
#include <libtorrent/alert.hpp>
#include <libtorrent/alert_types.hpp>
#include <libtorrent/settings_pack.hpp>
#include <libtorrent/peer_class.hpp>
#include <libtorrent/peer_class_type_filter.hpp>
#include <libtorrent/ip_filter.hpp>
#include <libtorrent/session_types.hpp>
#include <libtorrent/session_params.hpp>
#include <libtorrent/session_handle.hpp>
#include <libtorrent/session.hpp>
#include <libtorrent/create_torrent.hpp>
#include <libtorrent/session_stats.hpp>
#include <libtorrent/version.hpp>
#include <libtorrent/magnet_uri.hpp>
#include <libtorrent/fingerprint.hpp>
#include <libtorrent/read_resume_data.hpp>
#include <libtorrent/write_resume_data.hpp>
#include <libtorrent/posix_disk_io.hpp>

#include <libtorrent/hex.hpp>
#include <libtorrent/bencode.hpp>

using piece_index_t = libtorrent::piece_index_t;
using file_index_t = libtorrent::file_index_t;
using queue_position_t = libtorrent::queue_position_t;

#include "libtorrent.hpp"



template <typename IndexType>
using typed_bitfield = libtorrent::typed_bitfield<IndexType>;

using add_torrent_params = libtorrent::add_torrent_params;
using address = libtorrent::address;
using bdecode_node = libtorrent::bdecode_node;
using client_data_t = libtorrent::client_data_t;
using close_reason_t = libtorrent::close_reason_t;
using disconnect_severity_t = libtorrent::disconnect_severity_t;
using download_priority_t = libtorrent::download_priority_t;
using event_t = libtorrent::event_t;
using file_slice = libtorrent::file_slice;
using file_storage = libtorrent::file_storage;
using info_hash_t = libtorrent::info_hash_t;
using operation_t = libtorrent::operation_t;
using peer_connection = libtorrent::peer_connection;
using peer_info = libtorrent::peer_info;
using peer_request = libtorrent::peer_request;
using peer_source_flags_t = libtorrent::peer_source_flags_t;
using pex_flags_t = libtorrent::pex_flags_t;
using portmap_transport = libtorrent::portmap_transport;
using portmap_protocol = libtorrent::portmap_protocol;
using protocol_version = libtorrent::protocol_version;
using reopen_network_flags_t = libtorrent::reopen_network_flags_t;
using save_state_flags_t = libtorrent::save_state_flags_t;
using session_flags_t = libtorrent::session_flags_t;
using session_params = libtorrent::session_params;
using settings_pack = libtorrent::settings_pack;
using sha1_hash_vector = std::vector<libtorrent::digest32<160>>;
using sha256_hash_vector = std::vector<libtorrent::digest32<256>>;
using socket_type_t = libtorrent::socket_type_t;
using storage_mode_t = libtorrent::storage_mode_t;
using tcp = libtorrent::tcp;
using torrent_flags_t = libtorrent::torrent_flags_t;
using torrent_info = libtorrent::torrent_info;
using udp = libtorrent::udp;

// END common set include ------------------------------------------------------


#include <stdint.h>		// Use the C99 official header


#include <typeinfo>
#include <stdexcept>


#include <string>


SWIGINTERN void SWIG_JavaException(JNIEnv *jenv, int code, const char *msg) {
  SWIG_JavaExceptionCodes exception_code = SWIG_JavaUnknownError;
  switch(code) {
  case SWIG_MemoryError:
    exception_code = SWIG_JavaOutOfMemoryError;
    break;
  case SWIG_IOError:
    exception_code = SWIG_JavaIOException;
    break;
  case SWIG_SystemError:
  case SWIG_RuntimeError:
    exception_code = SWIG_JavaRuntimeException;
    break;
  case SWIG_OverflowError:
  case SWIG_IndexError:
    exception_code = SWIG_JavaIndexOutOfBoundsException;
    break;
  case SWIG_DivisionByZero:
    exception_code = SWIG_JavaArithmeticException;
    break;
  case SWIG_SyntaxError:
  case SWIG_ValueError:
  case SWIG_TypeError:
    exception_code = SWIG_JavaIllegalArgumentException;
    break;
  case SWIG_NullReferenceError:
    exception_code = SWIG_JavaNullPointerException;
    break;
  case SWIG_UnknownError:
  default:
    exception_code = SWIG_JavaUnknownError;
    break;
  }
  SWIG_JavaThrowException(jenv, exception_code, msg);
}


#include <typeinfo>
#include <stdexcept>


#include <utility>


#include <vector>
#include <stdexcept>


#include <map>
#include <stdexcept>


/* Check for overflow converting to Java int (always signed 32-bit) from (unsigned variable-bit) size_t */
SWIGINTERN jint SWIG_JavaIntFromSize_t(size_t size) {
  static const jint JINT_MAX = 0x7FFFFFFF;
  return (size > (size_t)JINT_MAX) ? -1 : (jint)size;
}


SWIGINTERN jint SWIG_VectorSize(size_t size) {
  jint sz = SWIG_JavaIntFromSize_t(size);
  if (sz == -1)
    throw std::out_of_range("vector size is too large to fit into a Java int");
  return sz;
}

SWIGINTERN std::vector< std::string > *new_std_vector_Sl_std_string_Sg___SWIG_2(jint count,std::string const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::string >(static_cast<std::vector< std::string >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_string_Sg__doCapacity(std::vector< std::string > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__doReserve(std::vector< std::string > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_string_Sg__doSize(std::vector< std::string > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__doAdd__SWIG_0(std::vector< std::string > *self,std::vector< std::string >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__doAdd__SWIG_1(std::vector< std::string > *self,jint index,std::vector< std::string >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__doRemove(std::vector< std::string > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::string const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::string >::value_type const &std_vector_Sl_std_string_Sg__doGet(std::vector< std::string > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::string >::value_type std_vector_Sl_std_string_Sg__doSet(std::vector< std::string > *self,jint index,std::vector< std::string >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::string const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_string_Sg__doRemoveRange(std::vector< std::string > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< int > *new_std_vector_Sl_int_Sg___SWIG_2(jint count,int const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< int >(static_cast<std::vector< int >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_int_Sg__doCapacity(std::vector< int > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_int_Sg__doReserve(std::vector< int > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_int_Sg__doSize(std::vector< int > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_int_Sg__doAdd__SWIG_0(std::vector< int > *self,std::vector< int >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_int_Sg__doAdd__SWIG_1(std::vector< int > *self,jint index,std::vector< int >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__doRemove(std::vector< int > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          int const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< int >::value_type const &std_vector_Sl_int_Sg__doGet(std::vector< int > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< int >::value_type std_vector_Sl_int_Sg__doSet(std::vector< int > *self,jint index,std::vector< int >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          int const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_int_Sg__doRemoveRange(std::vector< int > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< long long > *new_std_vector_Sl_long_SS_long_Sg___SWIG_2(jint count,long long const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< long long >(static_cast<std::vector< long long >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_long_SS_long_Sg__doCapacity(std::vector< long long > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_long_SS_long_Sg__doReserve(std::vector< long long > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_long_SS_long_Sg__doSize(std::vector< long long > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_long_SS_long_Sg__doAdd__SWIG_0(std::vector< long long > *self,std::vector< long long >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_long_SS_long_Sg__doAdd__SWIG_1(std::vector< long long > *self,jint index,std::vector< long long >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< long long >::value_type std_vector_Sl_long_SS_long_Sg__doRemove(std::vector< long long > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          long long const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< long long >::value_type const &std_vector_Sl_long_SS_long_Sg__doGet(std::vector< long long > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< long long >::value_type std_vector_Sl_long_SS_long_Sg__doSet(std::vector< long long > *self,jint index,std::vector< long long >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          long long const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_long_SS_long_Sg__doRemoveRange(std::vector< long long > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::int8_t > *new_std_vector_Sl_std_int8_t_Sg___SWIG_2(jint count,std::int8_t const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::int8_t >(static_cast<std::vector< std::int8_t >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_int8_t_Sg__doCapacity(std::vector< std::int8_t > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_int8_t_Sg__doReserve(std::vector< std::int8_t > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_int8_t_Sg__doSize(std::vector< std::int8_t > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_int8_t_Sg__doAdd__SWIG_0(std::vector< std::int8_t > *self,std::vector< signed char >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_int8_t_Sg__doAdd__SWIG_1(std::vector< std::int8_t > *self,jint index,std::vector< signed char >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< signed char >::value_type std_vector_Sl_std_int8_t_Sg__doRemove(std::vector< std::int8_t > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::int8_t const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< signed char >::value_type const &std_vector_Sl_std_int8_t_Sg__doGet(std::vector< std::int8_t > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< signed char >::value_type std_vector_Sl_std_int8_t_Sg__doSet(std::vector< std::int8_t > *self,jint index,std::vector< signed char >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::int8_t const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_int8_t_Sg__doRemoveRange(std::vector< std::int8_t > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< bool > *new_std_vector_Sl_bool_Sg___SWIG_2(jint count,bool const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< bool >(static_cast<std::vector< bool >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_bool_Sg__doCapacity(std::vector< bool > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_bool_Sg__doReserve(std::vector< bool > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_bool_Sg__doSize(std::vector< bool > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_bool_Sg__doAdd__SWIG_0(std::vector< bool > *self,std::vector< bool >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_bool_Sg__doAdd__SWIG_1(std::vector< bool > *self,jint index,std::vector< bool >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< bool >::value_type std_vector_Sl_bool_Sg__doRemove(std::vector< bool > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          bool const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN bool std_vector_Sl_bool_Sg__doGet(std::vector< bool > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< bool >::value_type std_vector_Sl_bool_Sg__doSet(std::vector< bool > *self,jint index,std::vector< bool >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          bool const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_bool_Sg__doRemoveRange(std::vector< bool > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< int,std::int8_t > > *new_std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg___SWIG_2(jint count,std::pair< int,std::int8_t > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::pair< int,std::int8_t > >(static_cast<std::vector< std::pair< int,std::int8_t > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doCapacity(std::vector< std::pair< int,std::int8_t > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doReserve(std::vector< std::pair< int,std::int8_t > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doSize(std::vector< std::pair< int,std::int8_t > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doAdd__SWIG_0(std::vector< std::pair< int,std::int8_t > > *self,std::vector< std::pair< int,signed char > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doAdd__SWIG_1(std::vector< std::pair< int,std::int8_t > > *self,jint index,std::vector< std::pair< int,signed char > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< int,signed char > >::value_type std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doRemove(std::vector< std::pair< int,std::int8_t > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::pair< int,std::int8_t > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< int,signed char > >::value_type const &std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doGet(std::vector< std::pair< int,std::int8_t > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::pair< int,signed char > >::value_type std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doSet(std::vector< std::pair< int,std::int8_t > > *self,jint index,std::vector< std::pair< int,signed char > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::pair< int,std::int8_t > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doRemoveRange(std::vector< std::pair< int,std::int8_t > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< std::string,int > > *new_std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg___SWIG_2(jint count,std::pair< std::string,int > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::pair< std::string,int > >(static_cast<std::vector< std::pair< std::string,int > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doCapacity(std::vector< std::pair< std::string,int > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doReserve(std::vector< std::pair< std::string,int > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doSize(std::vector< std::pair< std::string,int > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doAdd__SWIG_0(std::vector< std::pair< std::string,int > > *self,std::vector< std::pair< std::string,int > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doAdd__SWIG_1(std::vector< std::pair< std::string,int > > *self,jint index,std::vector< std::pair< std::string,int > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< std::string,int > >::value_type std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doRemove(std::vector< std::pair< std::string,int > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::pair< std::string,int > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< std::string,int > >::value_type const &std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doGet(std::vector< std::pair< std::string,int > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::pair< std::string,int > >::value_type std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doSet(std::vector< std::pair< std::string,int > > *self,jint index,std::vector< std::pair< std::string,int > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::pair< std::string,int > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doRemoveRange(std::vector< std::pair< std::string,int > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< std::string,std::string > > *new_std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg___SWIG_2(jint count,std::pair< std::string,std::string > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::pair< std::string,std::string > >(static_cast<std::vector< std::pair< std::string,std::string > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doCapacity(std::vector< std::pair< std::string,std::string > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doReserve(std::vector< std::pair< std::string,std::string > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doSize(std::vector< std::pair< std::string,std::string > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doAdd__SWIG_0(std::vector< std::pair< std::string,std::string > > *self,std::vector< std::pair< std::string,std::string > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doAdd__SWIG_1(std::vector< std::pair< std::string,std::string > > *self,jint index,std::vector< std::pair< std::string,std::string > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< std::string,std::string > >::value_type std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doRemove(std::vector< std::pair< std::string,std::string > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::pair< std::string,std::string > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< std::string,std::string > >::value_type const &std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doGet(std::vector< std::pair< std::string,std::string > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::pair< std::string,std::string > >::value_type std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doSet(std::vector< std::pair< std::string,std::string > > *self,jint index,std::vector< std::pair< std::string,std::string > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::pair< std::string,std::string > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doRemoveRange(std::vector< std::pair< std::string,std::string > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::tcp::endpoint > *new_std_vector_Sl_libtorrent_tcp_endpoint_Sg___SWIG_2(jint count,libtorrent::tcp::endpoint const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::tcp::endpoint >(static_cast<std::vector< libtorrent::tcp::endpoint >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_tcp_endpoint_Sg__doCapacity(std::vector< libtorrent::tcp::endpoint > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_tcp_endpoint_Sg__doReserve(std::vector< libtorrent::tcp::endpoint > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_tcp_endpoint_Sg__doSize(std::vector< libtorrent::tcp::endpoint > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_tcp_endpoint_Sg__doAdd__SWIG_0(std::vector< libtorrent::tcp::endpoint > *self,std::vector< libtorrent::tcp::endpoint >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_tcp_endpoint_Sg__doAdd__SWIG_1(std::vector< libtorrent::tcp::endpoint > *self,jint index,std::vector< libtorrent::tcp::endpoint >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::tcp::endpoint >::value_type std_vector_Sl_libtorrent_tcp_endpoint_Sg__doRemove(std::vector< libtorrent::tcp::endpoint > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::tcp::endpoint const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::tcp::endpoint >::value_type const &std_vector_Sl_libtorrent_tcp_endpoint_Sg__doGet(std::vector< libtorrent::tcp::endpoint > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::tcp::endpoint >::value_type std_vector_Sl_libtorrent_tcp_endpoint_Sg__doSet(std::vector< libtorrent::tcp::endpoint > *self,jint index,std::vector< libtorrent::tcp::endpoint >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::tcp::endpoint const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_tcp_endpoint_Sg__doRemoveRange(std::vector< libtorrent::tcp::endpoint > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::udp::endpoint > *new_std_vector_Sl_libtorrent_udp_endpoint_Sg___SWIG_2(jint count,libtorrent::udp::endpoint const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::udp::endpoint >(static_cast<std::vector< libtorrent::udp::endpoint >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_udp_endpoint_Sg__doCapacity(std::vector< libtorrent::udp::endpoint > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_udp_endpoint_Sg__doReserve(std::vector< libtorrent::udp::endpoint > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_udp_endpoint_Sg__doSize(std::vector< libtorrent::udp::endpoint > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_udp_endpoint_Sg__doAdd__SWIG_0(std::vector< libtorrent::udp::endpoint > *self,std::vector< libtorrent::udp::endpoint >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_udp_endpoint_Sg__doAdd__SWIG_1(std::vector< libtorrent::udp::endpoint > *self,jint index,std::vector< libtorrent::udp::endpoint >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::udp::endpoint >::value_type std_vector_Sl_libtorrent_udp_endpoint_Sg__doRemove(std::vector< libtorrent::udp::endpoint > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::udp::endpoint const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::udp::endpoint >::value_type const &std_vector_Sl_libtorrent_udp_endpoint_Sg__doGet(std::vector< libtorrent::udp::endpoint > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::udp::endpoint >::value_type std_vector_Sl_libtorrent_udp_endpoint_Sg__doSet(std::vector< libtorrent::udp::endpoint > *self,jint index,std::vector< libtorrent::udp::endpoint >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::udp::endpoint const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_udp_endpoint_Sg__doRemoveRange(std::vector< libtorrent::udp::endpoint > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::announce_endpoint > *new_std_vector_Sl_libtorrent_announce_endpoint_Sg___SWIG_2(jint count,libtorrent::announce_endpoint const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::announce_endpoint >(static_cast<std::vector< libtorrent::announce_endpoint >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_announce_endpoint_Sg__doCapacity(std::vector< libtorrent::announce_endpoint > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_announce_endpoint_Sg__doReserve(std::vector< libtorrent::announce_endpoint > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_announce_endpoint_Sg__doSize(std::vector< libtorrent::announce_endpoint > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_announce_endpoint_Sg__doAdd__SWIG_0(std::vector< libtorrent::announce_endpoint > *self,std::vector< libtorrent::announce_endpoint >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_announce_endpoint_Sg__doAdd__SWIG_1(std::vector< libtorrent::announce_endpoint > *self,jint index,std::vector< libtorrent::announce_endpoint >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::announce_endpoint >::value_type std_vector_Sl_libtorrent_announce_endpoint_Sg__doRemove(std::vector< libtorrent::announce_endpoint > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::announce_endpoint const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::announce_endpoint >::value_type const &std_vector_Sl_libtorrent_announce_endpoint_Sg__doGet(std::vector< libtorrent::announce_endpoint > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::announce_endpoint >::value_type std_vector_Sl_libtorrent_announce_endpoint_Sg__doSet(std::vector< libtorrent::announce_endpoint > *self,jint index,std::vector< libtorrent::announce_endpoint >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::announce_endpoint const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_announce_endpoint_Sg__doRemoveRange(std::vector< libtorrent::announce_endpoint > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::announce_entry > *new_std_vector_Sl_libtorrent_announce_entry_Sg___SWIG_2(jint count,libtorrent::announce_entry const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::announce_entry >(static_cast<std::vector< libtorrent::announce_entry >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_announce_entry_Sg__doCapacity(std::vector< libtorrent::announce_entry > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_announce_entry_Sg__doReserve(std::vector< libtorrent::announce_entry > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_announce_entry_Sg__doSize(std::vector< libtorrent::announce_entry > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_announce_entry_Sg__doAdd__SWIG_0(std::vector< libtorrent::announce_entry > *self,std::vector< libtorrent::announce_entry >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_announce_entry_Sg__doAdd__SWIG_1(std::vector< libtorrent::announce_entry > *self,jint index,std::vector< libtorrent::announce_entry >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::announce_entry >::value_type std_vector_Sl_libtorrent_announce_entry_Sg__doRemove(std::vector< libtorrent::announce_entry > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::announce_entry const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::announce_entry >::value_type const &std_vector_Sl_libtorrent_announce_entry_Sg__doGet(std::vector< libtorrent::announce_entry > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::announce_entry >::value_type std_vector_Sl_libtorrent_announce_entry_Sg__doSet(std::vector< libtorrent::announce_entry > *self,jint index,std::vector< libtorrent::announce_entry >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::announce_entry const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_announce_entry_Sg__doRemoveRange(std::vector< libtorrent::announce_entry > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::web_seed_entry > *new_std_vector_Sl_libtorrent_web_seed_entry_Sg___SWIG_2(jint count,libtorrent::web_seed_entry const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::web_seed_entry >(static_cast<std::vector< libtorrent::web_seed_entry >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_web_seed_entry_Sg__doCapacity(std::vector< libtorrent::web_seed_entry > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_web_seed_entry_Sg__doReserve(std::vector< libtorrent::web_seed_entry > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_web_seed_entry_Sg__doSize(std::vector< libtorrent::web_seed_entry > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_web_seed_entry_Sg__doAdd__SWIG_0(std::vector< libtorrent::web_seed_entry > *self,std::vector< libtorrent::web_seed_entry >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_web_seed_entry_Sg__doAdd__SWIG_1(std::vector< libtorrent::web_seed_entry > *self,jint index,std::vector< libtorrent::web_seed_entry >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::web_seed_entry >::value_type std_vector_Sl_libtorrent_web_seed_entry_Sg__doRemove(std::vector< libtorrent::web_seed_entry > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::web_seed_entry const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::web_seed_entry >::value_type const &std_vector_Sl_libtorrent_web_seed_entry_Sg__doGet(std::vector< libtorrent::web_seed_entry > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::web_seed_entry >::value_type std_vector_Sl_libtorrent_web_seed_entry_Sg__doSet(std::vector< libtorrent::web_seed_entry > *self,jint index,std::vector< libtorrent::web_seed_entry >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::web_seed_entry const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_web_seed_entry_Sg__doRemoveRange(std::vector< libtorrent::web_seed_entry > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::file_slice > *new_std_vector_Sl_libtorrent_file_slice_Sg___SWIG_2(jint count,libtorrent::file_slice const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::file_slice >(static_cast<std::vector< libtorrent::file_slice >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_file_slice_Sg__doCapacity(std::vector< libtorrent::file_slice > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_file_slice_Sg__doReserve(std::vector< libtorrent::file_slice > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_file_slice_Sg__doSize(std::vector< libtorrent::file_slice > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_file_slice_Sg__doAdd__SWIG_0(std::vector< libtorrent::file_slice > *self,std::vector< libtorrent::file_slice >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_file_slice_Sg__doAdd__SWIG_1(std::vector< libtorrent::file_slice > *self,jint index,std::vector< libtorrent::file_slice >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::file_slice >::value_type std_vector_Sl_libtorrent_file_slice_Sg__doRemove(std::vector< libtorrent::file_slice > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::file_slice const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::file_slice >::value_type const &std_vector_Sl_libtorrent_file_slice_Sg__doGet(std::vector< libtorrent::file_slice > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::file_slice >::value_type std_vector_Sl_libtorrent_file_slice_Sg__doSet(std::vector< libtorrent::file_slice > *self,jint index,std::vector< libtorrent::file_slice >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::file_slice const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_file_slice_Sg__doRemoveRange(std::vector< libtorrent::file_slice > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::piece_block > *new_std_vector_Sl_libtorrent_piece_block_Sg___SWIG_2(jint count,libtorrent::piece_block const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::piece_block >(static_cast<std::vector< libtorrent::piece_block >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_piece_block_Sg__doCapacity(std::vector< libtorrent::piece_block > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_piece_block_Sg__doReserve(std::vector< libtorrent::piece_block > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_piece_block_Sg__doSize(std::vector< libtorrent::piece_block > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_piece_block_Sg__doAdd__SWIG_0(std::vector< libtorrent::piece_block > *self,std::vector< libtorrent::piece_block >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_piece_block_Sg__doAdd__SWIG_1(std::vector< libtorrent::piece_block > *self,jint index,std::vector< libtorrent::piece_block >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::piece_block >::value_type std_vector_Sl_libtorrent_piece_block_Sg__doRemove(std::vector< libtorrent::piece_block > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::piece_block const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::piece_block >::value_type const &std_vector_Sl_libtorrent_piece_block_Sg__doGet(std::vector< libtorrent::piece_block > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::piece_block >::value_type std_vector_Sl_libtorrent_piece_block_Sg__doSet(std::vector< libtorrent::piece_block > *self,jint index,std::vector< libtorrent::piece_block >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::piece_block const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_piece_block_Sg__doRemoveRange(std::vector< libtorrent::piece_block > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::torrent_status > *new_std_vector_Sl_libtorrent_torrent_status_Sg___SWIG_2(jint count,libtorrent::torrent_status const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::torrent_status >(static_cast<std::vector< libtorrent::torrent_status >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_torrent_status_Sg__doCapacity(std::vector< libtorrent::torrent_status > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_torrent_status_Sg__doReserve(std::vector< libtorrent::torrent_status > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_torrent_status_Sg__doSize(std::vector< libtorrent::torrent_status > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_torrent_status_Sg__doAdd__SWIG_0(std::vector< libtorrent::torrent_status > *self,std::vector< libtorrent::torrent_status >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_torrent_status_Sg__doAdd__SWIG_1(std::vector< libtorrent::torrent_status > *self,jint index,std::vector< libtorrent::torrent_status >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::torrent_status >::value_type std_vector_Sl_libtorrent_torrent_status_Sg__doRemove(std::vector< libtorrent::torrent_status > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::torrent_status const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::torrent_status >::value_type const &std_vector_Sl_libtorrent_torrent_status_Sg__doGet(std::vector< libtorrent::torrent_status > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::torrent_status >::value_type std_vector_Sl_libtorrent_torrent_status_Sg__doSet(std::vector< libtorrent::torrent_status > *self,jint index,std::vector< libtorrent::torrent_status >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::torrent_status const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_torrent_status_Sg__doRemoveRange(std::vector< libtorrent::torrent_status > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::dht_lookup > *new_std_vector_Sl_libtorrent_dht_lookup_Sg___SWIG_2(jint count,libtorrent::dht_lookup const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::dht_lookup >(static_cast<std::vector< libtorrent::dht_lookup >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_dht_lookup_Sg__doCapacity(std::vector< libtorrent::dht_lookup > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_dht_lookup_Sg__doReserve(std::vector< libtorrent::dht_lookup > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_dht_lookup_Sg__doSize(std::vector< libtorrent::dht_lookup > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_dht_lookup_Sg__doAdd__SWIG_0(std::vector< libtorrent::dht_lookup > *self,std::vector< libtorrent::dht_lookup >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_dht_lookup_Sg__doAdd__SWIG_1(std::vector< libtorrent::dht_lookup > *self,jint index,std::vector< libtorrent::dht_lookup >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::dht_lookup >::value_type std_vector_Sl_libtorrent_dht_lookup_Sg__doRemove(std::vector< libtorrent::dht_lookup > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::dht_lookup const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::dht_lookup >::value_type const &std_vector_Sl_libtorrent_dht_lookup_Sg__doGet(std::vector< libtorrent::dht_lookup > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::dht_lookup >::value_type std_vector_Sl_libtorrent_dht_lookup_Sg__doSet(std::vector< libtorrent::dht_lookup > *self,jint index,std::vector< libtorrent::dht_lookup >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::dht_lookup const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_dht_lookup_Sg__doRemoveRange(std::vector< libtorrent::dht_lookup > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::dht_routing_bucket > *new_std_vector_Sl_libtorrent_dht_routing_bucket_Sg___SWIG_2(jint count,libtorrent::dht_routing_bucket const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::dht_routing_bucket >(static_cast<std::vector< libtorrent::dht_routing_bucket >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doCapacity(std::vector< libtorrent::dht_routing_bucket > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doReserve(std::vector< libtorrent::dht_routing_bucket > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doSize(std::vector< libtorrent::dht_routing_bucket > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doAdd__SWIG_0(std::vector< libtorrent::dht_routing_bucket > *self,std::vector< libtorrent::dht_routing_bucket >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doAdd__SWIG_1(std::vector< libtorrent::dht_routing_bucket > *self,jint index,std::vector< libtorrent::dht_routing_bucket >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::dht_routing_bucket >::value_type std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doRemove(std::vector< libtorrent::dht_routing_bucket > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::dht_routing_bucket const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::dht_routing_bucket >::value_type const &std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doGet(std::vector< libtorrent::dht_routing_bucket > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::dht_routing_bucket >::value_type std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doSet(std::vector< libtorrent::dht_routing_bucket > *self,jint index,std::vector< libtorrent::dht_routing_bucket >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::dht_routing_bucket const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doRemoveRange(std::vector< libtorrent::dht_routing_bucket > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::entry > *new_std_vector_Sl_libtorrent_entry_Sg___SWIG_2(jint count,libtorrent::entry const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::entry >(static_cast<std::vector< libtorrent::entry >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_entry_Sg__doCapacity(std::vector< libtorrent::entry > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_entry_Sg__doReserve(std::vector< libtorrent::entry > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_entry_Sg__doSize(std::vector< libtorrent::entry > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_entry_Sg__doAdd__SWIG_0(std::vector< libtorrent::entry > *self,std::vector< libtorrent::entry >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_entry_Sg__doAdd__SWIG_1(std::vector< libtorrent::entry > *self,jint index,std::vector< libtorrent::entry >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::entry >::value_type std_vector_Sl_libtorrent_entry_Sg__doRemove(std::vector< libtorrent::entry > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::entry const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::entry >::value_type const &std_vector_Sl_libtorrent_entry_Sg__doGet(std::vector< libtorrent::entry > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::entry >::value_type std_vector_Sl_libtorrent_entry_Sg__doSet(std::vector< libtorrent::entry > *self,jint index,std::vector< libtorrent::entry >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::entry const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_entry_Sg__doRemoveRange(std::vector< libtorrent::entry > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::partial_piece_info > *new_std_vector_Sl_libtorrent_partial_piece_info_Sg___SWIG_2(jint count,libtorrent::partial_piece_info const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::partial_piece_info >(static_cast<std::vector< libtorrent::partial_piece_info >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_partial_piece_info_Sg__doCapacity(std::vector< libtorrent::partial_piece_info > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_partial_piece_info_Sg__doReserve(std::vector< libtorrent::partial_piece_info > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_partial_piece_info_Sg__doSize(std::vector< libtorrent::partial_piece_info > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_partial_piece_info_Sg__doAdd__SWIG_0(std::vector< libtorrent::partial_piece_info > *self,std::vector< libtorrent::partial_piece_info >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_partial_piece_info_Sg__doAdd__SWIG_1(std::vector< libtorrent::partial_piece_info > *self,jint index,std::vector< libtorrent::partial_piece_info >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::partial_piece_info >::value_type std_vector_Sl_libtorrent_partial_piece_info_Sg__doRemove(std::vector< libtorrent::partial_piece_info > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::partial_piece_info const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::partial_piece_info >::value_type const &std_vector_Sl_libtorrent_partial_piece_info_Sg__doGet(std::vector< libtorrent::partial_piece_info > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::partial_piece_info >::value_type std_vector_Sl_libtorrent_partial_piece_info_Sg__doSet(std::vector< libtorrent::partial_piece_info > *self,jint index,std::vector< libtorrent::partial_piece_info >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::partial_piece_info const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_partial_piece_info_Sg__doRemoveRange(std::vector< libtorrent::partial_piece_info > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::peer_info > *new_std_vector_Sl_libtorrent_peer_info_Sg___SWIG_2(jint count,libtorrent::peer_info const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::peer_info >(static_cast<std::vector< libtorrent::peer_info >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_peer_info_Sg__doCapacity(std::vector< libtorrent::peer_info > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_peer_info_Sg__doReserve(std::vector< libtorrent::peer_info > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_peer_info_Sg__doSize(std::vector< libtorrent::peer_info > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_peer_info_Sg__doAdd__SWIG_0(std::vector< libtorrent::peer_info > *self,std::vector< libtorrent::peer_info >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_peer_info_Sg__doAdd__SWIG_1(std::vector< libtorrent::peer_info > *self,jint index,std::vector< libtorrent::peer_info >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::peer_info >::value_type std_vector_Sl_libtorrent_peer_info_Sg__doRemove(std::vector< libtorrent::peer_info > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::peer_info const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::peer_info >::value_type const &std_vector_Sl_libtorrent_peer_info_Sg__doGet(std::vector< libtorrent::peer_info > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::peer_info >::value_type std_vector_Sl_libtorrent_peer_info_Sg__doSet(std::vector< libtorrent::peer_info > *self,jint index,std::vector< libtorrent::peer_info >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::peer_info const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_peer_info_Sg__doRemoveRange(std::vector< libtorrent::peer_info > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::torrent_handle > *new_std_vector_Sl_libtorrent_torrent_handle_Sg___SWIG_2(jint count,libtorrent::torrent_handle const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::torrent_handle >(static_cast<std::vector< libtorrent::torrent_handle >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_torrent_handle_Sg__doCapacity(std::vector< libtorrent::torrent_handle > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_torrent_handle_Sg__doReserve(std::vector< libtorrent::torrent_handle > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_torrent_handle_Sg__doSize(std::vector< libtorrent::torrent_handle > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_torrent_handle_Sg__doAdd__SWIG_0(std::vector< libtorrent::torrent_handle > *self,std::vector< libtorrent::torrent_handle >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_torrent_handle_Sg__doAdd__SWIG_1(std::vector< libtorrent::torrent_handle > *self,jint index,std::vector< libtorrent::torrent_handle >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::torrent_handle >::value_type std_vector_Sl_libtorrent_torrent_handle_Sg__doRemove(std::vector< libtorrent::torrent_handle > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::torrent_handle const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::torrent_handle >::value_type const &std_vector_Sl_libtorrent_torrent_handle_Sg__doGet(std::vector< libtorrent::torrent_handle > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::torrent_handle >::value_type std_vector_Sl_libtorrent_torrent_handle_Sg__doSet(std::vector< libtorrent::torrent_handle > *self,jint index,std::vector< libtorrent::torrent_handle >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::torrent_handle const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_torrent_handle_Sg__doRemoveRange(std::vector< libtorrent::torrent_handle > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::alert * > *new_std_vector_Sl_libtorrent_alert_Sm__Sg___SWIG_2(jint count,libtorrent::alert *const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::alert * >(static_cast<std::vector< libtorrent::alert * >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_alert_Sm__Sg__doCapacity(std::vector< libtorrent::alert * > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_alert_Sm__Sg__doReserve(std::vector< libtorrent::alert * > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_alert_Sm__Sg__doSize(std::vector< libtorrent::alert * > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_alert_Sm__Sg__doAdd__SWIG_0(std::vector< libtorrent::alert * > *self,std::vector< libtorrent::alert * >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_alert_Sm__Sg__doAdd__SWIG_1(std::vector< libtorrent::alert * > *self,jint index,std::vector< libtorrent::alert * >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::alert * >::value_type std_vector_Sl_libtorrent_alert_Sm__Sg__doRemove(std::vector< libtorrent::alert * > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::alert * const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::alert * >::value_type const &std_vector_Sl_libtorrent_alert_Sm__Sg__doGet(std::vector< libtorrent::alert * > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::alert * >::value_type std_vector_Sl_libtorrent_alert_Sm__Sg__doSet(std::vector< libtorrent::alert * > *self,jint index,std::vector< libtorrent::alert * >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::alert * const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_alert_Sm__Sg__doRemoveRange(std::vector< libtorrent::alert * > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::stats_metric > *new_std_vector_Sl_libtorrent_stats_metric_Sg___SWIG_2(jint count,libtorrent::stats_metric const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::stats_metric >(static_cast<std::vector< libtorrent::stats_metric >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_stats_metric_Sg__doCapacity(std::vector< libtorrent::stats_metric > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_stats_metric_Sg__doReserve(std::vector< libtorrent::stats_metric > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_stats_metric_Sg__doSize(std::vector< libtorrent::stats_metric > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_stats_metric_Sg__doAdd__SWIG_0(std::vector< libtorrent::stats_metric > *self,std::vector< libtorrent::stats_metric >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_stats_metric_Sg__doAdd__SWIG_1(std::vector< libtorrent::stats_metric > *self,jint index,std::vector< libtorrent::stats_metric >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::stats_metric >::value_type std_vector_Sl_libtorrent_stats_metric_Sg__doRemove(std::vector< libtorrent::stats_metric > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::stats_metric const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::stats_metric >::value_type const &std_vector_Sl_libtorrent_stats_metric_Sg__doGet(std::vector< libtorrent::stats_metric > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::stats_metric >::value_type std_vector_Sl_libtorrent_stats_metric_Sg__doSet(std::vector< libtorrent::stats_metric > *self,jint index,std::vector< libtorrent::stats_metric >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::stats_metric const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_stats_metric_Sg__doRemoveRange(std::vector< libtorrent::stats_metric > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< ip_interface > *new_std_vector_Sl_ip_interface_Sg___SWIG_2(jint count,ip_interface const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< ip_interface >(static_cast<std::vector< ip_interface >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_ip_interface_Sg__doCapacity(std::vector< ip_interface > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_ip_interface_Sg__doReserve(std::vector< ip_interface > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_ip_interface_Sg__doSize(std::vector< ip_interface > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_ip_interface_Sg__doAdd__SWIG_0(std::vector< ip_interface > *self,std::vector< ip_interface >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_ip_interface_Sg__doAdd__SWIG_1(std::vector< ip_interface > *self,jint index,std::vector< ip_interface >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< ip_interface >::value_type std_vector_Sl_ip_interface_Sg__doRemove(std::vector< ip_interface > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          ip_interface const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< ip_interface >::value_type const &std_vector_Sl_ip_interface_Sg__doGet(std::vector< ip_interface > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< ip_interface >::value_type std_vector_Sl_ip_interface_Sg__doSet(std::vector< ip_interface > *self,jint index,std::vector< ip_interface >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          ip_interface const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_ip_interface_Sg__doRemoveRange(std::vector< ip_interface > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< ip_route > *new_std_vector_Sl_ip_route_Sg___SWIG_2(jint count,ip_route const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< ip_route >(static_cast<std::vector< ip_route >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_ip_route_Sg__doCapacity(std::vector< ip_route > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_ip_route_Sg__doReserve(std::vector< ip_route > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_ip_route_Sg__doSize(std::vector< ip_route > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_ip_route_Sg__doAdd__SWIG_0(std::vector< ip_route > *self,std::vector< ip_route >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_ip_route_Sg__doAdd__SWIG_1(std::vector< ip_route > *self,jint index,std::vector< ip_route >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< ip_route >::value_type std_vector_Sl_ip_route_Sg__doRemove(std::vector< ip_route > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          ip_route const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< ip_route >::value_type const &std_vector_Sl_ip_route_Sg__doGet(std::vector< ip_route > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< ip_route >::value_type std_vector_Sl_ip_route_Sg__doSet(std::vector< ip_route > *self,jint index,std::vector< ip_route >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          ip_route const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_ip_route_Sg__doRemoveRange(std::vector< ip_route > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::block_info > *new_std_vector_Sl_libtorrent_block_info_Sg___SWIG_2(jint count,libtorrent::block_info const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::block_info >(static_cast<std::vector< libtorrent::block_info >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_block_info_Sg__doCapacity(std::vector< libtorrent::block_info > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_block_info_Sg__doReserve(std::vector< libtorrent::block_info > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_block_info_Sg__doSize(std::vector< libtorrent::block_info > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_block_info_Sg__doAdd__SWIG_0(std::vector< libtorrent::block_info > *self,std::vector< libtorrent::block_info >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_block_info_Sg__doAdd__SWIG_1(std::vector< libtorrent::block_info > *self,jint index,std::vector< libtorrent::block_info >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::block_info >::value_type std_vector_Sl_libtorrent_block_info_Sg__doRemove(std::vector< libtorrent::block_info > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::block_info const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::block_info >::value_type const &std_vector_Sl_libtorrent_block_info_Sg__doGet(std::vector< libtorrent::block_info > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::block_info >::value_type std_vector_Sl_libtorrent_block_info_Sg__doSet(std::vector< libtorrent::block_info > *self,jint index,std::vector< libtorrent::block_info >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::block_info const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_block_info_Sg__doRemoveRange(std::vector< libtorrent::block_info > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::bitfield > *new_std_vector_Sl_libtorrent_bitfield_Sg___SWIG_2(jint count,libtorrent::bitfield const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::bitfield >(static_cast<std::vector< libtorrent::bitfield >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_bitfield_Sg__doCapacity(std::vector< libtorrent::bitfield > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_bitfield_Sg__doReserve(std::vector< libtorrent::bitfield > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_bitfield_Sg__doSize(std::vector< libtorrent::bitfield > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_bitfield_Sg__doAdd__SWIG_0(std::vector< libtorrent::bitfield > *self,std::vector< libtorrent::bitfield >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_bitfield_Sg__doAdd__SWIG_1(std::vector< libtorrent::bitfield > *self,jint index,std::vector< libtorrent::bitfield >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::bitfield >::value_type std_vector_Sl_libtorrent_bitfield_Sg__doRemove(std::vector< libtorrent::bitfield > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::bitfield const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::bitfield >::value_type const &std_vector_Sl_libtorrent_bitfield_Sg__doGet(std::vector< libtorrent::bitfield > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::bitfield >::value_type std_vector_Sl_libtorrent_bitfield_Sg__doSet(std::vector< libtorrent::bitfield > *self,jint index,std::vector< libtorrent::bitfield >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::bitfield const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_bitfield_Sg__doRemoveRange(std::vector< libtorrent::bitfield > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::vector< bool > > *new_std_vector_Sl_std_vector_Sl_bool_Sg__Sg___SWIG_2(jint count,std::vector< bool > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::vector< bool > >(static_cast<std::vector< std::vector< bool > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doCapacity(std::vector< std::vector< bool > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doReserve(std::vector< std::vector< bool > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doSize(std::vector< std::vector< bool > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doAdd__SWIG_0(std::vector< std::vector< bool > > *self,std::vector< std::vector< bool > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doAdd__SWIG_1(std::vector< std::vector< bool > > *self,jint index,std::vector< std::vector< bool > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::vector< bool > >::value_type std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doRemove(std::vector< std::vector< bool > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::vector< bool > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::vector< bool > >::value_type const &std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doGet(std::vector< std::vector< bool > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::vector< bool > >::value_type std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doSet(std::vector< std::vector< bool > > *self,jint index,std::vector< std::vector< bool > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::vector< bool > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doRemoveRange(std::vector< std::vector< bool > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::vector< libtorrent::digest32< 256 > > > *new_std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg___SWIG_2(jint count,std::vector< libtorrent::digest32< 256 > > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::vector< libtorrent::digest32< 256 > > >(static_cast<std::vector< std::vector< libtorrent::digest32< 256 > > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doCapacity(std::vector< std::vector< libtorrent::digest32< 256 > > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doReserve(std::vector< std::vector< libtorrent::digest32< 256 > > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doSize(std::vector< std::vector< libtorrent::digest32< 256 > > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doAdd__SWIG_0(std::vector< std::vector< libtorrent::digest32< 256 > > > *self,std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doAdd__SWIG_1(std::vector< std::vector< libtorrent::digest32< 256 > > > *self,jint index,std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doRemove(std::vector< std::vector< libtorrent::digest32< 256 > > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::vector< libtorrent::digest32< 256 > > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type const &std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doGet(std::vector< std::vector< libtorrent::digest32< 256 > > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doSet(std::vector< std::vector< libtorrent::digest32< 256 > > > *self,jint index,std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::vector< libtorrent::digest32< 256 > > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doRemoveRange(std::vector< std::vector< libtorrent::digest32< 256 > > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *new_std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg___SWIG_2(jint count,std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >(static_cast<std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doCapacity(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doReserve(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doSize(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doAdd__SWIG_0(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *self,std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doAdd__SWIG_1(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *self,jint index,std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doRemove(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type const &std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doGet(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doSet(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *self,jint index,std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doRemoveRange(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *new_std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg___SWIG_2(jint count,std::pair< libtorrent::address,libtorrent::digest32< 160 > > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >(static_cast<std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doCapacity(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doReserve(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doSize(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doAdd__SWIG_0(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *self,std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doAdd__SWIG_1(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *self,jint index,std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doRemove(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::pair< libtorrent::address,libtorrent::digest32< 160 > > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type const &std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doGet(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doSet(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *self,jint index,std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::pair< libtorrent::address,libtorrent::digest32< 160 > > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doRemoveRange(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }

  SWIGINTERN jint SWIG_ArraySize(size_t size) {
    jint sz = SWIG_JavaIntFromSize_t(size);
    if (sz == -1) {
      throw std::out_of_range("array size is too large to fit into a Java int");
    }

    return sz;
  }

SWIGINTERN jint std_array_Sl_std_int8_t_Sc_32_Sg__size(std::array< std::int8_t,32 > const *self){
        return SWIG_ArraySize(self->size());
      }
SWIGINTERN std::array< signed char,32 >::const_reference std_array_Sl_std_int8_t_Sc_32_Sg__get(std::array< std::int8_t,32 > *self,int i){
        int size = int(self->size());
        if (i>=0 && i<size)
          return (*self)[i];
        else
          throw std::out_of_range("array index out of range");
      }
SWIGINTERN void std_array_Sl_std_int8_t_Sc_32_Sg__set(std::array< std::int8_t,32 > *self,int i,std::array< signed char,32 >::value_type const &val){
        int size = int(self->size());
        if (i>=0 && i<size)
          (*self)[i] = val;
        else
          throw std::out_of_range("array index out of range");
      }
SWIGINTERN jint std_array_Sl_std_int8_t_Sc_64_Sg__size(std::array< std::int8_t,64 > const *self){
        return SWIG_ArraySize(self->size());
      }
SWIGINTERN std::array< signed char,64 >::const_reference std_array_Sl_std_int8_t_Sc_64_Sg__get(std::array< std::int8_t,64 > *self,int i){
        int size = int(self->size());
        if (i>=0 && i<size)
          return (*self)[i];
        else
          throw std::out_of_range("array index out of range");
      }
SWIGINTERN void std_array_Sl_std_int8_t_Sc_64_Sg__set(std::array< std::int8_t,64 > *self,int i,std::array< signed char,64 >::value_type const &val){
        int size = int(self->size());
        if (i>=0 && i<size)
          (*self)[i] = val;
        else
          throw std::out_of_range("array index out of range");
      }
SWIGINTERN std::map< int,std::string,std::less< int > >::iterator std_map_Sl_int_Sc_std_string_Sg__iterator_getNextUnchecked(std::map< int,std::string >::iterator *self){
          std::map< int, std::string, std::less< int > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_int_Sc_std_string_Sg__iterator_isNot(std::map< int,std::string >::iterator const *self,std::map< int,std::string >::iterator other){
          return (*self != other);
        }
SWIGINTERN int std_map_Sl_int_Sc_std_string_Sg__iterator_getKey(std::map< int,std::string >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN std::string std_map_Sl_int_Sc_std_string_Sg__iterator_getValue(std::map< int,std::string >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_int_Sc_std_string_Sg__iterator_setValue(std::map< int,std::string >::iterator *self,std::string const &newValue){
          (*self)->second = newValue;
        }

  SWIGINTERN jint SWIG_MapSize(size_t size) {
    jint sz = SWIG_JavaIntFromSize_t(size);
    if (sz == -1) {
      throw std::out_of_range("map size is too large to fit into a Java int");
    }

    return sz;
  }

SWIGINTERN jint std_map_Sl_int_Sc_std_string_Sg__sizeImpl(std::map< int,std::string > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_int_Sc_std_string_Sg__containsImpl(std::map< int,std::string > *self,int const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_int_Sc_std_string_Sg__putUnchecked(std::map< int,std::string > *self,int const &key,std::string const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_int_Sc_std_string_Sg__removeUnchecked(std::map< int,std::string > *self,std::map< int,std::string,std::less< int > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN std::map< std::string,std::string,std::less< std::string > >::iterator std_map_Sl_std_string_Sc_std_string_Sg__iterator_getNextUnchecked(std::map< std::string,std::string >::iterator *self){
          std::map< std::string, std::string, std::less< std::string > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__iterator_isNot(std::map< std::string,std::string >::iterator const *self,std::map< std::string,std::string >::iterator other){
          return (*self != other);
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_std_string_Sg__iterator_getKey(std::map< std::string,std::string >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_std_string_Sg__iterator_getValue(std::map< std::string,std::string >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__iterator_setValue(std::map< std::string,std::string >::iterator *self,std::string const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_std_string_Sc_std_string_Sg__sizeImpl(std::map< std::string,std::string > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_std_string_Sg__containsImpl(std::map< std::string,std::string > *self,std::string const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__putUnchecked(std::map< std::string,std::string > *self,std::string const &key,std::string const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_std_string_Sc_std_string_Sg__removeUnchecked(std::map< std::string,std::string > *self,std::map< std::string,std::string,std::less< std::string > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN std::map< int,libtorrent::bitfield,std::less< int > >::iterator std_map_Sl_int_Sc_libtorrent_bitfield_Sg__iterator_getNextUnchecked(std::map< int,libtorrent::bitfield >::iterator *self){
          std::map< int, libtorrent::bitfield, std::less< int > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_int_Sc_libtorrent_bitfield_Sg__iterator_isNot(std::map< int,libtorrent::bitfield >::iterator const *self,std::map< int,libtorrent::bitfield >::iterator other){
          return (*self != other);
        }
SWIGINTERN int std_map_Sl_int_Sc_libtorrent_bitfield_Sg__iterator_getKey(std::map< int,libtorrent::bitfield >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN libtorrent::bitfield std_map_Sl_int_Sc_libtorrent_bitfield_Sg__iterator_getValue(std::map< int,libtorrent::bitfield >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_int_Sc_libtorrent_bitfield_Sg__iterator_setValue(std::map< int,libtorrent::bitfield >::iterator *self,libtorrent::bitfield const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_int_Sc_libtorrent_bitfield_Sg__sizeImpl(std::map< int,libtorrent::bitfield > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_int_Sc_libtorrent_bitfield_Sg__containsImpl(std::map< int,libtorrent::bitfield > *self,int const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_int_Sc_libtorrent_bitfield_Sg__putUnchecked(std::map< int,libtorrent::bitfield > *self,int const &key,libtorrent::bitfield const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_int_Sc_libtorrent_bitfield_Sg__removeUnchecked(std::map< int,libtorrent::bitfield > *self,std::map< int,libtorrent::bitfield,std::less< int > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN std::map< std::string,libtorrent::entry,std::less< std::string > >::iterator std_map_Sl_std_string_Sc_libtorrent_entry_Sg__iterator_getNextUnchecked(std::map< std::string,libtorrent::entry >::iterator *self){
          std::map< std::string, libtorrent::entry, std::less< std::string > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_std_string_Sc_libtorrent_entry_Sg__iterator_isNot(std::map< std::string,libtorrent::entry >::iterator const *self,std::map< std::string,libtorrent::entry >::iterator other){
          return (*self != other);
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_libtorrent_entry_Sg__iterator_getKey(std::map< std::string,libtorrent::entry >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN libtorrent::entry std_map_Sl_std_string_Sc_libtorrent_entry_Sg__iterator_getValue(std::map< std::string,libtorrent::entry >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_std_string_Sc_libtorrent_entry_Sg__iterator_setValue(std::map< std::string,libtorrent::entry >::iterator *self,libtorrent::entry const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_std_string_Sc_libtorrent_entry_Sg__sizeImpl(std::map< std::string,libtorrent::entry > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_libtorrent_entry_Sg__containsImpl(std::map< std::string,libtorrent::entry > *self,std::string const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_std_string_Sc_libtorrent_entry_Sg__putUnchecked(std::map< std::string,libtorrent::entry > *self,std::string const &key,libtorrent::entry const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_std_string_Sc_libtorrent_entry_Sg__removeUnchecked(std::map< std::string,libtorrent::entry > *self,std::map< std::string,libtorrent::entry,std::less< std::string > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN bool boost_container_map_Sl_std_string_Sc_libtorrent_entry_Sg__contains(boost::container::map< std::string,libtorrent::entry > *self,std::string const &k){
            return self->contains(k);
        }
SWIGINTERN void boost_container_map_Sl_std_string_Sc_libtorrent_entry_Sg__put(boost::container::map< std::string,libtorrent::entry > *self,std::string const &k,libtorrent::entry &v){
            self->operator[](k) = v;
        }
SWIGINTERN libtorrent::entry &boost_container_map_Sl_std_string_Sc_libtorrent_entry_Sg__get(boost::container::map< std::string,libtorrent::entry > *self,std::string const &k){
            return self->operator[](k);
        }
SWIGINTERN std::vector< std::string > boost_container_map_Sl_std_string_Sc_libtorrent_entry_Sg__keys(boost::container::map< std::string,libtorrent::entry > *self){
            std::vector<std::string> r;

            for (auto const& e : *self)
            {
                r.emplace_back(e.first);
            }

            return r;
        }
SWIGINTERN void boost_container_map_Sl_std_string_Sc_libtorrent_entry_Sg__remove(boost::container::map< std::string,libtorrent::entry > *self,std::string const &key){
            self->extract(key);
        }
SWIGINTERN std::map< libtorrent::file_index_t,std::string,std::less< libtorrent::file_index_t > >::iterator std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__iterator_getNextUnchecked(std::map< libtorrent::file_index_t,std::string >::iterator *self){
          std::map< libtorrent::file_index_t, std::string, std::less< libtorrent::file_index_t > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__iterator_isNot(std::map< libtorrent::file_index_t,std::string >::iterator const *self,std::map< libtorrent::file_index_t,std::string >::iterator other){
          return (*self != other);
        }
SWIGINTERN libtorrent::file_index_t std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__iterator_getKey(std::map< libtorrent::file_index_t,std::string >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN std::string std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__iterator_getValue(std::map< libtorrent::file_index_t,std::string >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__iterator_setValue(std::map< libtorrent::file_index_t,std::string >::iterator *self,std::string const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__sizeImpl(std::map< libtorrent::file_index_t,std::string > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__containsImpl(std::map< libtorrent::file_index_t,std::string > *self,libtorrent::file_index_t const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__putUnchecked(std::map< libtorrent::file_index_t,std::string > *self,libtorrent::file_index_t const &key,std::string const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__removeUnchecked(std::map< libtorrent::file_index_t,std::string > *self,std::map< libtorrent::file_index_t,std::string,std::less< libtorrent::file_index_t > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN std::vector< libtorrent::file_index_t > *new_std_vector_Sl_libtorrent_file_index_t_Sg___SWIG_2(jint count,libtorrent::file_index_t const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::file_index_t >(static_cast<std::vector< libtorrent::file_index_t >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_file_index_t_Sg__doCapacity(std::vector< libtorrent::file_index_t > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_file_index_t_Sg__doReserve(std::vector< libtorrent::file_index_t > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_file_index_t_Sg__doSize(std::vector< libtorrent::file_index_t > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_file_index_t_Sg__doAdd__SWIG_0(std::vector< libtorrent::file_index_t > *self,std::vector< libtorrent::file_index_t >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_file_index_t_Sg__doAdd__SWIG_1(std::vector< libtorrent::file_index_t > *self,jint index,std::vector< libtorrent::file_index_t >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::file_index_t >::value_type std_vector_Sl_libtorrent_file_index_t_Sg__doRemove(std::vector< libtorrent::file_index_t > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::file_index_t const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::file_index_t >::value_type const &std_vector_Sl_libtorrent_file_index_t_Sg__doGet(std::vector< libtorrent::file_index_t > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::file_index_t >::value_type std_vector_Sl_libtorrent_file_index_t_Sg__doSet(std::vector< libtorrent::file_index_t > *self,jint index,std::vector< libtorrent::file_index_t >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::file_index_t const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_file_index_t_Sg__doRemoveRange(std::vector< libtorrent::file_index_t > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< libtorrent::piece_index_t,int > > *new_std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg___SWIG_2(jint count,std::pair< libtorrent::piece_index_t,int > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< std::pair< libtorrent::piece_index_t,int > >(static_cast<std::vector< std::pair< libtorrent::piece_index_t,int > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doCapacity(std::vector< std::pair< libtorrent::piece_index_t,int > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doReserve(std::vector< std::pair< libtorrent::piece_index_t,int > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doSize(std::vector< std::pair< libtorrent::piece_index_t,int > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doAdd__SWIG_0(std::vector< std::pair< libtorrent::piece_index_t,int > > *self,std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doAdd__SWIG_1(std::vector< std::pair< libtorrent::piece_index_t,int > > *self,jint index,std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doRemove(std::vector< std::pair< libtorrent::piece_index_t,int > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          std::pair< libtorrent::piece_index_t,int > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type const &std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doGet(std::vector< std::pair< libtorrent::piece_index_t,int > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doSet(std::vector< std::pair< libtorrent::piece_index_t,int > > *self,jint index,std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          std::pair< libtorrent::piece_index_t,int > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doRemoveRange(std::vector< std::pair< libtorrent::piece_index_t,int > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::piece_index_t > *new_std_vector_Sl_libtorrent_piece_index_t_Sg___SWIG_2(jint count,libtorrent::piece_index_t const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::piece_index_t >(static_cast<std::vector< libtorrent::piece_index_t >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_piece_index_t_Sg__doCapacity(std::vector< libtorrent::piece_index_t > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_piece_index_t_Sg__doReserve(std::vector< libtorrent::piece_index_t > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_piece_index_t_Sg__doSize(std::vector< libtorrent::piece_index_t > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_piece_index_t_Sg__doAdd__SWIG_0(std::vector< libtorrent::piece_index_t > *self,std::vector< libtorrent::piece_index_t >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_piece_index_t_Sg__doAdd__SWIG_1(std::vector< libtorrent::piece_index_t > *self,jint index,std::vector< libtorrent::piece_index_t >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::piece_index_t >::value_type std_vector_Sl_libtorrent_piece_index_t_Sg__doRemove(std::vector< libtorrent::piece_index_t > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::piece_index_t const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::piece_index_t >::value_type const &std_vector_Sl_libtorrent_piece_index_t_Sg__doGet(std::vector< libtorrent::piece_index_t > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::piece_index_t >::value_type std_vector_Sl_libtorrent_piece_index_t_Sg__doSet(std::vector< libtorrent::piece_index_t > *self,jint index,std::vector< libtorrent::piece_index_t >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::piece_index_t const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_piece_index_t_Sg__doRemoveRange(std::vector< libtorrent::piece_index_t > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::map< std::string,long,std::less< std::string > >::iterator std_map_Sl_std_string_Sc_long_Sg__iterator_getNextUnchecked(std::map< std::string,long >::iterator *self){
          std::map< std::string, long, std::less< std::string > >::iterator copy = (*self);
          return ++copy;
        }
SWIGINTERN bool std_map_Sl_std_string_Sc_long_Sg__iterator_isNot(std::map< std::string,long >::iterator const *self,std::map< std::string,long >::iterator other){
          return (*self != other);
        }
SWIGINTERN std::string std_map_Sl_std_string_Sc_long_Sg__iterator_getKey(std::map< std::string,long >::iterator const *self){
          return (*self)->first;
        }
SWIGINTERN long std_map_Sl_std_string_Sc_long_Sg__iterator_getValue(std::map< std::string,long >::iterator const *self){
          return (*self)->second;
        }
SWIGINTERN void std_map_Sl_std_string_Sc_long_Sg__iterator_setValue(std::map< std::string,long >::iterator *self,long const &newValue){
          (*self)->second = newValue;
        }
SWIGINTERN jint std_map_Sl_std_string_Sc_long_Sg__sizeImpl(std::map< std::string,long > const *self){
        return SWIG_MapSize(self->size());
      }
SWIGINTERN bool std_map_Sl_std_string_Sc_long_Sg__containsImpl(std::map< std::string,long > *self,std::string const &key){
        return (self->count(key) > 0);
      }
SWIGINTERN void std_map_Sl_std_string_Sc_long_Sg__putUnchecked(std::map< std::string,long > *self,std::string const &key,long const &value){
#ifdef __cpp_lib_map_try_emplace
        (*self).insert_or_assign(key, value);
#else
        (*self)[key] = value;
#endif
      }
SWIGINTERN void std_map_Sl_std_string_Sc_long_Sg__removeUnchecked(std::map< std::string,long > *self,std::map< std::string,long,std::less< std::string > >::iterator const itr){
        self->erase(itr);
      }
SWIGINTERN bool std_bitset_Sl_128_Sg__get(std::bitset< 128 > *self,std::size_t pos){
                return (*self)[pos];
            }
SWIGINTERN bool std_bitset_Sl_96_Sg__get(std::bitset< 96 > *self,std::size_t pos){
                return (*self)[pos];
            }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::bandwidth_state_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint32_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint32_t, libtorrent::create_flags_tag>(static_cast<std::uint32_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::file_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint32_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint32_t, libtorrent::peer_flags_tag>(static_cast<std::uint32_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::peer_source_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::pex_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint32_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint32_t, libtorrent::picker_flags_tag>(static_cast<std::uint32_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint32_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint32_t, libtorrent::write_torrent_flags_tag>(static_cast<std::uint32_t>(val));
                }
SWIGINTERN int8_t libtorrent_span_Sl_char_Sg__get(libtorrent::span< char > *self,size_t const idx){
                return (*self)[idx];
            }
SWIGINTERN void libtorrent_span_Sl_char_Sg__set(libtorrent::span< char > *self,size_t const idx,int8_t val){
                (*self)[idx] = val;
            }
SWIGINTERN int8_t libtorrent_span_Sl_char_SS_const_Sg__get(libtorrent::span< char const > *self,size_t const idx){
                return (*self)[idx];
            }
SWIGINTERN bool libtorrent_address_op_lt(libtorrent::address *self,libtorrent::address const &a2){
                return *self < a2;
            }
SWIGINTERN int libtorrent_address_compare(libtorrent::address const &a1,libtorrent::address const &a2){
                return a1 == a2 ? 0 : (a1 < a2 ? -1 : 1);
            }
SWIGINTERN libtorrent::address libtorrent_address_from_string(std::string const &str,boost::system::error_code &ec){
                return boost::asio::ip::make_address(str, ec);
            }
SWIGINTERN int libtorrent_address_hash_code(libtorrent::address *self){
                if (self->is_v4())
                {
                    auto data = self->to_v4().to_bytes();
                    int result = 1;
                    for (int i = 0; i < int(data.size()); i++)
                    {
                        result = 31 * result + data[i];
                    }
                    return result;
                }
                else
                {
                    auto data = self->to_v6().to_bytes();
                    int result = 1;
                    for (int i = 0; i < int(data.size()); i++)
                    {
                        result = 31 * result + data[i];
                    }
                    return result;
                }
            }
SWIGINTERN void *libtorrent_client_data_t_get(libtorrent::client_data_t *self){
            return self->get<void>();
        }
SWIGINTERN libtorrent::digest32< 160 > *new_libtorrent_digest32_Sl_160_Sg___SWIG_2(std::vector< std::int8_t > const &v){
        if (static_cast<std::size_t>(libtorrent::digest32<160>::size()) != v.size()) {
            throw std::invalid_argument("digest32<160>(std::vector<std::int8_t> const& v): sha1 size must be 20 bytes");
        }
        return new libtorrent::digest32<160>(libtorrent::span(reinterpret_cast<char const*>(v.data()), static_cast<long>(v.size())));
    }
SWIGINTERN void libtorrent_digest32_Sl_160_Sg__assign(libtorrent::digest32< 160 > *self,std::vector< std::int8_t > const &v){
        if (static_cast<std::size_t>(self->size()) != v.size()) {
            throw std::invalid_argument("digest32<160>::assign(std::vector<std::int8_t> const& v): sha1 size must be 20 bytes");
        }
        self->assign(reinterpret_cast<char const*>(v.data()));
    }
SWIGINTERN int libtorrent_digest32_Sl_160_Sg__hash_code(libtorrent::digest32< 160 > *self){
        char const* data = self->data();
        int result = 1;
        for (int i = 0; i < int(self->size()); i++)
        {
            // avoid signed-char UB / platform differences
            //result = 31 * result + data[i];
            result = 31 * result + static_cast<unsigned char>(data[i]);
        }
        return result;
    }
SWIGINTERN std::vector< std::int8_t > libtorrent_digest32_Sl_160_Sg__to_bytes(libtorrent::digest32< 160 > *self){
        std::string s = self->to_string();
        return std::vector<std::int8_t>(s.begin(), s.end());
    }
SWIGINTERN std::string libtorrent_digest32_Sl_160_Sg__to_hex(libtorrent::digest32< 160 > *self){
        return libtorrent::aux::to_hex(*self);
    }
SWIGINTERN libtorrent::digest32< 160 > libtorrent_digest32_Sl_160_Sg__from_hex(std::string s){
        libtorrent::digest32<160> hash;
        //libtorrent::aux::from_hex(s, hash.data());
        libtorrent::aux::from_hex(libtorrent::span<char const>(s.data(), static_cast<long>(s.size())),hash.data());
        return hash;
    }
SWIGINTERN int libtorrent_digest32_Sl_160_Sg__compare(libtorrent::digest32< 160 > const &h1,libtorrent::digest32< 160 > const &h2){
        return h1 == h2 ? 0 : (h1 < h2 ? -1 : 1);
    }
SWIGINTERN libtorrent::digest32< 256 > *new_libtorrent_digest32_Sl_256_Sg___SWIG_2(std::vector< std::int8_t > const &v){
        if (static_cast<std::size_t>(libtorrent::digest32<256>::size()) != v.size()) {
            throw std::invalid_argument("digest32<256>(std::vector<std::int8_t> const& v): sha256 size must be 32 bytes");
        }

        return new libtorrent::digest32<256>(libtorrent::span(reinterpret_cast<char const*>(v.data()), static_cast<long>(v.size())));
    }
SWIGINTERN void libtorrent_digest32_Sl_256_Sg__assign(libtorrent::digest32< 256 > *self,std::vector< std::int8_t > const &v){
        if (static_cast<std::size_t>(self->size()) != v.size()) {
            throw std::invalid_argument("digest32<256>::assign(std::vector<std::size_t> const& v): sha256 size must be 32 bytes");
        }
        self->assign(reinterpret_cast<char const*>(v.data()));
    }
SWIGINTERN int libtorrent_digest32_Sl_256_Sg__hash_code(libtorrent::digest32< 256 > *self){
        char const* data = self->data();
        int result = 1;
        for (int i = 0; i < int(self->size()); i++)
        {
            //result = 31 * result + data[i];
            result = 31 * result + static_cast<unsigned char>(data[i]);
        }
        return result;
    }
SWIGINTERN std::vector< std::int8_t > libtorrent_digest32_Sl_256_Sg__to_bytes(libtorrent::digest32< 256 > *self){
        std::string s = self->to_string();
        return std::vector<std::int8_t>(s.begin(), s.end());
    }
SWIGINTERN std::string libtorrent_digest32_Sl_256_Sg__to_hex(libtorrent::digest32< 256 > *self){
        return libtorrent::aux::to_hex(*self);
    }
SWIGINTERN libtorrent::digest32< 256 > libtorrent_digest32_Sl_256_Sg__from_hex(std::string s){
        libtorrent::digest32<256> hash;
        libtorrent::aux::from_hex(libtorrent::span<char const>(s.data(), static_cast<long>(s.size())),hash.data());
        return hash;
    }
SWIGINTERN int libtorrent_digest32_Sl_256_Sg__compare(libtorrent::digest32< 256 > const &h1,libtorrent::digest32< 256 > const &h2){
        return h1 == h2 ? 0 : (h1 < h2 ? -1 : 1);
    }
SWIGINTERN std::vector< libtorrent::digest32< 160 > > *new_std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg___SWIG_2(jint count,libtorrent::digest32< 160 > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::digest32< 160 > >(static_cast<std::vector< libtorrent::digest32< 160 > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doCapacity(std::vector< libtorrent::digest32< 160 > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doReserve(std::vector< libtorrent::digest32< 160 > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doSize(std::vector< libtorrent::digest32< 160 > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doAdd__SWIG_0(std::vector< libtorrent::digest32< 160 > > *self,std::vector< libtorrent::digest32< 160 > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doAdd__SWIG_1(std::vector< libtorrent::digest32< 160 > > *self,jint index,std::vector< libtorrent::digest32< 160 > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::digest32< 160 > >::value_type std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doRemove(std::vector< libtorrent::digest32< 160 > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::digest32< 160 > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::digest32< 160 > >::value_type const &std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doGet(std::vector< libtorrent::digest32< 160 > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::digest32< 160 > >::value_type std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doSet(std::vector< libtorrent::digest32< 160 > > *self,jint index,std::vector< libtorrent::digest32< 160 > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::digest32< 160 > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doRemoveRange(std::vector< libtorrent::digest32< 160 > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::digest32< 256 > > *new_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg___SWIG_2(jint count,libtorrent::digest32< 256 > const &value){
        if (count < 0)
          throw std::out_of_range("vector count must be positive");
        return new std::vector< libtorrent::digest32< 256 > >(static_cast<std::vector< libtorrent::digest32< 256 > >::size_type>(count), value);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doCapacity(std::vector< libtorrent::digest32< 256 > > *self){
        return SWIG_VectorSize(self->capacity());
      }
SWIGINTERN void std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doReserve(std::vector< libtorrent::digest32< 256 > > *self,jint n){
        if (n < 0)
          throw std::out_of_range("vector reserve size must be positive");
        self->reserve(n);
      }
SWIGINTERN jint std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doSize(std::vector< libtorrent::digest32< 256 > > const *self){
        return SWIG_VectorSize(self->size());
      }
SWIGINTERN void std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doAdd__SWIG_0(std::vector< libtorrent::digest32< 256 > > *self,std::vector< libtorrent::digest32< 256 > >::value_type const &x){
        self->push_back(x);
      }
SWIGINTERN void std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doAdd__SWIG_1(std::vector< libtorrent::digest32< 256 > > *self,jint index,std::vector< libtorrent::digest32< 256 > >::value_type const &x){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index <= size) {
          self->insert(self->begin() + index, x);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::digest32< 256 > >::value_type std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doRemove(std::vector< libtorrent::digest32< 256 > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (0 <= index && index < size) {
          libtorrent::digest32< 256 > const old_value = (*self)[index];
          self->erase(self->begin() + index);
          return old_value;
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN std::vector< libtorrent::digest32< 256 > >::value_type const &std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doGet(std::vector< libtorrent::digest32< 256 > > *self,jint index){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size)
          return (*self)[index];
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN std::vector< libtorrent::digest32< 256 > >::value_type std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doSet(std::vector< libtorrent::digest32< 256 > > *self,jint index,std::vector< libtorrent::digest32< 256 > >::value_type const &val){
        jint size = static_cast<jint>(self->size());
        if (index >= 0 && index < size) {
          libtorrent::digest32< 256 > const old_value = (*self)[index];
          (*self)[index] = val;
          return old_value;
        }
        else
          throw std::out_of_range("vector index out of range");
      }
SWIGINTERN void std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doRemoveRange(std::vector< libtorrent::digest32< 256 > > *self,jint fromIndex,jint toIndex){
        jint size = static_cast<jint>(self->size());
        if (0 <= fromIndex && fromIndex <= toIndex && toIndex <= size) {
          self->erase(self->begin() + fromIndex, self->begin() + toIndex);
        } else {
          throw std::out_of_range("vector index out of range");
        }
      }
SWIGINTERN bool libtorrent_info_hash_t_op_eq(libtorrent::info_hash_t const *self,libtorrent::info_hash_t const &n){
            return *self == n;
        }
SWIGINTERN bool libtorrent_info_hash_t_op_ne(libtorrent::info_hash_t const *self,libtorrent::info_hash_t const &n){
            return *self != n;
        }
SWIGINTERN libtorrent::bitfield *new_libtorrent_bitfield__SWIG_4(std::vector< std::int8_t > const &v){
            return new libtorrent::bitfield({reinterpret_cast<char const*>(v.data()), static_cast<int>(v.size())});
        }
SWIGINTERN void libtorrent_bitfield_assign(libtorrent::bitfield *self,std::vector< std::int8_t > const &v){
            self->assign(reinterpret_cast<char const*>(v.data()), static_cast<int>(v.size()));
        }
SWIGINTERN std::int64_t libtorrent_announce_infohash_get_next_announce(libtorrent::announce_infohash *self){
            return libtorrent::total_milliseconds(self->next_announce.time_since_epoch());
        }
SWIGINTERN std::int64_t libtorrent_announce_infohash_get_min_announce(libtorrent::announce_infohash *self){
            return libtorrent::total_milliseconds(self->min_announce.time_since_epoch());
        }
SWIGINTERN libtorrent::announce_infohash libtorrent_announce_endpoint_get_infohash_v1(libtorrent::announce_endpoint *self){
            return self->info_hashes[libtorrent::protocol_version::V1];
        }
SWIGINTERN libtorrent::announce_infohash libtorrent_announce_endpoint_get_infohash_v2(libtorrent::announce_endpoint *self){
            return self->info_hashes[libtorrent::protocol_version::V2];
        }
SWIGINTERN libtorrent::announce_entry *new_libtorrent_announce_entry__SWIG_2(std::string url){
            return new libtorrent::announce_entry(url);
        }
SWIGINTERN libtorrent::announce_entry *new_libtorrent_announce_entry__SWIG_3(std::vector< int8_t > const &u){
                return new libtorrent::announce_entry(
                    {reinterpret_cast<char const*>(u.data()), u.size()});
            }
SWIGINTERN std::vector< int8_t > libtorrent_announce_entry_get_url(libtorrent::announce_entry *self){
                std::string s = self->url;
                return {s.begin(), s.end()};
            }
SWIGINTERN void libtorrent_announce_entry_set_url(libtorrent::announce_entry *self,std::vector< int8_t > const &s){
                self->url = {s.begin(), s.end()};
            }
SWIGINTERN std::vector< int8_t > libtorrent_announce_entry_get_trackerid(libtorrent::announce_entry *self){
                std::string s = self->trackerid;
                return {s.begin(), s.end()};
            }
SWIGINTERN void libtorrent_announce_entry_set_trackerid(libtorrent::announce_entry *self,std::vector< int8_t > const &s){
                self->trackerid = {s.begin(), s.end()};
            }
SWIGINTERN void libtorrent_file_storage_add_file_ex__SWIG_0(libtorrent::file_storage *self,libtorrent::error_code &ec,std::string const &path,std::int64_t file_size,libtorrent::file_flags_t file_flags={},std::time_t mtime=0,std::string symlink_path={}){
            self->add_file(ec, path, file_size, file_flags, mtime, symlink_path);
        }
SWIGINTERN std::string libtorrent_file_storage_file_name_ex(libtorrent::file_storage *self,int index){
            return std::string{self->file_name(libtorrent::file_index_t{index})};
        }
SWIGINTERN std::vector< std::string > libtorrent_file_storage_file_paths_ex(libtorrent::file_storage *self){
            std::vector<std::string> result;
            int num_files = self->num_files();
            result.reserve(num_files);

            for (int i = 0; i < num_files; ++i) {
                std::string path = self->file_path(libtorrent::file_index_t{i});
                result.push_back(path);
            }
            return result;
        }
SWIGINTERN std::string libtorrent_bdecode_node_list_string_value_at_s__SWIG_0(libtorrent::bdecode_node *self,int i,std::string default_val=""){
            return self->list_string_value_at(i, default_val).to_string();
        }
SWIGINTERN libtorrent::bdecode_node libtorrent_bdecode_node_dict_find_s(libtorrent::bdecode_node const *self,std::string key){
            return self->dict_find(key);
        }
SWIGINTERN libtorrent::bdecode_node libtorrent_bdecode_node_dict_find_dict_s(libtorrent::bdecode_node const *self,std::string key){
            return self->dict_find_dict(key);
        }
SWIGINTERN libtorrent::bdecode_node libtorrent_bdecode_node_dict_find_list_s(libtorrent::bdecode_node const *self,std::string key){
            return self->dict_find_list(key);
        }
SWIGINTERN libtorrent::bdecode_node libtorrent_bdecode_node_dict_find_string_s(libtorrent::bdecode_node const *self,std::string key){
            return self->dict_find_string(key);
        }
SWIGINTERN libtorrent::bdecode_node libtorrent_bdecode_node_dict_find_int_s(libtorrent::bdecode_node const *self,std::string key){
            return self->dict_find_int(key);
        }
SWIGINTERN std::string libtorrent_bdecode_node_dict_find_string_value_s__SWIG_0(libtorrent::bdecode_node const *self,std::string key,std::string default_value=""){
            return self->dict_find_string_value(key, default_value).to_string();
        }
SWIGINTERN std::int64_t libtorrent_bdecode_node_dict_find_int_value_s__SWIG_0(libtorrent::bdecode_node const *self,std::string key,std::int64_t default_val=0){
            return self->dict_find_int_value(key, default_val);
        }
SWIGINTERN std::string libtorrent_bdecode_node_string_value_s(libtorrent::bdecode_node const *self){
            return self->string_value().to_string();
        }
SWIGINTERN std::string libtorrent_bdecode_node_string_value_ex(libtorrent::bdecode_node const *self){
                return std::string{self->string_value()};
        }
SWIGINTERN std::string libtorrent_bdecode_node_to_string(libtorrent::bdecode_node const &e,bool single_line,int indent){
            return libtorrent::print_entry(e, single_line, indent);
        }
SWIGINTERN int libtorrent_bdecode_node_bdecode(std::vector< int8_t > &buffer,libtorrent::bdecode_node &ret,libtorrent::error_code &ec){
            return libtorrent::bdecode((char const*)&buffer[0], (char const*)&buffer[0] + buffer.size(), ret, ec);
        }
SWIGINTERN libtorrent::torrent_info *new_libtorrent_torrent_info__SWIG_4(std::int64_t buffer_ptr,int size,libtorrent::error_code &ec){
            return new libtorrent::torrent_info(reinterpret_cast<char const*>(buffer_ptr), size, ec);
        }
SWIGINTERN libtorrent::span< std::int8_t const > libtorrent_torrent_info_get_info_section(libtorrent::torrent_info *self){
            auto v = self->info_section();
            return libtorrent::span<std::int8_t const>({reinterpret_cast<std::int8_t const*>(v.data()), v.size()});
        }
SWIGINTERN std::string libtorrent_torrent_info_get_ssl_cert(libtorrent::torrent_info *self){
            return std::string(self->ssl_cert());
        }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint64_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint64_t, libtorrent::torrent_flags_tag>(static_cast<std::uint64_t>(val));
                }
SWIGINTERN libtorrent::torrent_info const *libtorrent_add_torrent_params_ti_ptr(libtorrent::add_torrent_params *self){
            return self->ti.get();
        }
SWIGINTERN void libtorrent_add_torrent_params_set_ti(libtorrent::add_torrent_params *self,libtorrent::torrent_info const &ti){
            self->ti = std::make_shared<libtorrent::torrent_info>(ti);
        }
SWIGINTERN std::vector< std::int8_t > libtorrent_add_torrent_params_get_file_priorities(libtorrent::add_torrent_params *self){
            auto* v = &self->file_priorities;
            return *reinterpret_cast<std::vector<std::int8_t>*>(v);
        }
SWIGINTERN void libtorrent_add_torrent_params_set_renamed_files__SWIG_0(libtorrent::add_torrent_params *self,std::map< file_index_t,std::string,std::less< file_index_t > > const &renamed_files){
            self->renamed_files = renamed_files;
        }
SWIGINTERN void libtorrent_add_torrent_params_set_renamed_files__SWIG_1(libtorrent::add_torrent_params *self,std::map< int,std::string,std::less< int > > &v){
            auto* t = reinterpret_cast<std::map<libtorrent::file_index_t, std::string>*>(&v);
            self->renamed_files = *t;
        }
SWIGINTERN std::vector< int > libtorrent_add_torrent_params_get_tracker_tiers(libtorrent::add_torrent_params *self){
            return self->tracker_tiers;
        }
SWIGINTERN void libtorrent_add_torrent_params_set_tracker_tiers(libtorrent::add_torrent_params *self,std::vector< int > const &tracker_tiers){
            self->tracker_tiers = tracker_tiers;
        }
SWIGINTERN std::vector< libtorrent::tcp::endpoint > libtorrent_add_torrent_params_get_banned_peers(libtorrent::add_torrent_params *self){
            return self->banned_peers;
        }
SWIGINTERN void libtorrent_add_torrent_params_set_banned_peers(libtorrent::add_torrent_params *self,std::vector< libtorrent::tcp::endpoint > const &banned_peers){
            self->banned_peers = banned_peers;
        }
SWIGINTERN std::vector< libtorrent::tcp::endpoint > libtorrent_add_torrent_params_get_peers(libtorrent::add_torrent_params *self){
            return self->peers;
        }
SWIGINTERN void libtorrent_add_torrent_params_set_peers(libtorrent::add_torrent_params *self,std::vector< libtorrent::tcp::endpoint > const &peers){
            self->peers = peers;
        }
SWIGINTERN void libtorrent_add_torrent_params_set_file_priorities2(libtorrent::add_torrent_params *self,std::vector< std::int8_t > const &file_priorities){
            std::vector<download_priority_t> v(file_priorities.size());
            for (std::size_t i = 0; i < v.size(); i++)
                v[i] = download_priority_t{std::uint8_t(file_priorities[i])};
            self->file_priorities = v;
        }
SWIGINTERN void libtorrent_add_torrent_params_set_file_priorities(libtorrent::add_torrent_params *self,std::vector< std::int8_t > &v){
            auto* t = reinterpret_cast<std::vector<libtorrent::download_priority_t>*>(&v);
            self->file_priorities = *t;
        }
SWIGINTERN std::vector< std::int8_t > libtorrent_add_torrent_params_get_piece_priorities(libtorrent::add_torrent_params *self){
            auto* v = &self->piece_priorities;
            return *reinterpret_cast<std::vector<std::int8_t>*>(v);
        }
SWIGINTERN void libtorrent_add_torrent_params_set_piece_priorities(libtorrent::add_torrent_params *self,std::vector< std::int8_t > &v){
            auto* t = reinterpret_cast<std::vector<libtorrent::download_priority_t>*>(&v);
            self->piece_priorities = *t;
        }
SWIGINTERN std::vector< std::pair< std::string,int > > libtorrent_add_torrent_params_get_dht_nodes(libtorrent::add_torrent_params *self){
            return self->dht_nodes;
        }
SWIGINTERN void libtorrent_add_torrent_params_set_dht_nodes(libtorrent::add_torrent_params *self,std::vector< std::pair< std::string,int > > const &dht_nodes){
            self->dht_nodes = dht_nodes;
        }
SWIGINTERN void libtorrent_add_torrent_params_set_http_seeds(libtorrent::add_torrent_params *self,std::vector< std::string > const &http_seeds){
            self->http_seeds = http_seeds;
        }
SWIGINTERN std::vector< std::string > libtorrent_add_torrent_params_get_url_seeds(libtorrent::add_torrent_params *self){
            return self->url_seeds;
        }
SWIGINTERN void libtorrent_add_torrent_params_set_url_seeds(libtorrent::add_torrent_params *self,std::vector< std::string > const &url_seeds){
            self->url_seeds = url_seeds;
        }
SWIGINTERN std::vector< std::string > libtorrent_add_torrent_params_get_trackers(libtorrent::add_torrent_params *self){
            return self->trackers;
        }
SWIGINTERN void libtorrent_add_torrent_params_set_trackers(libtorrent::add_torrent_params *self,std::vector< std::string > const &trackers){
            self->trackers = trackers;
        }
SWIGINTERN std::vector< std::vector< libtorrent::sha256_hash > > libtorrent_add_torrent_params_get_merkle_trees(libtorrent::add_torrent_params *self){
            auto* v = &self->merkle_trees;
            return *reinterpret_cast<std::vector<std::vector<libtorrent::sha256_hash>>*>(v);
        }
SWIGINTERN void libtorrent_add_torrent_params_set_merkle_trees(libtorrent::add_torrent_params *self,std::vector< std::vector< libtorrent::sha256_hash > > &v){
            auto* t = reinterpret_cast<libtorrent::aux::vector<std::vector<libtorrent::sha256_hash>, libtorrent::file_index_t>*>(&v);
            self->merkle_trees = *t;
        }
SWIGINTERN std::vector< libtorrent::bitfield > libtorrent_add_torrent_params_get_merkle_tree_mask(libtorrent::add_torrent_params *self){
            auto* v = &self->merkle_tree_mask;
            return *reinterpret_cast<std::vector<libtorrent::bitfield>*>(v);
        }
SWIGINTERN void libtorrent_add_torrent_params_set_piece_priorities2(libtorrent::add_torrent_params *self,std::vector< std::int8_t > const &piece_priorities){
            std::vector<download_priority_t> v(piece_priorities.size());
            for (std::size_t i = 0; i < v.size(); i++)
                v[i] = download_priority_t{std::uint8_t(piece_priorities[i])};
            self->piece_priorities = v;
        }
SWIGINTERN std::vector< std::vector< bool > > const &libtorrent_add_torrent_params_get_verified_leaf_hashes_old(libtorrent::add_torrent_params *self){
            static std::vector<std::vector<bool>> result;
            result.clear();
            auto* v = &self->verified_leaf_hashes;
            result.reserve(v->size());
            for (const auto& item : *v) {
                result.push_back(item);
            }
            return result;
        }
SWIGINTERN std::vector< libtorrent::bitfield > libtorrent_add_torrent_params_get_verified_leaf_hashes(libtorrent::add_torrent_params *self){
            auto* v = &self->verified_leaf_hashes;
            return *reinterpret_cast<std::vector<libtorrent::bitfield>*>(v);
        }
SWIGINTERN std::map< int,libtorrent::bitfield,std::less< int > > libtorrent_add_torrent_params_get_unfinished_pieces(libtorrent::add_torrent_params *self){
            auto* v = &self->unfinished_pieces;
            return *reinterpret_cast<std::map<int, libtorrent::bitfield>*>(v);
        }
SWIGINTERN void libtorrent_add_torrent_params_set_unfinished_pieces(libtorrent::add_torrent_params *self,std::map< int,libtorrent::bitfield,std::less< int > > &v){
            auto* t = reinterpret_cast<std::map<libtorrent::piece_index_t, libtorrent::bitfield>*>(&v);
            self->unfinished_pieces = *t;
        }
SWIGINTERN std::map< int,std::string,std::less< int > > libtorrent_add_torrent_params_get_renamed_files(libtorrent::add_torrent_params *self){
            auto* v = &self->renamed_files;
            return *reinterpret_cast<std::map<int, std::string>*>(v);
        }
SWIGINTERN libtorrent::bitfield libtorrent_add_torrent_params_get_have_pieces(libtorrent::add_torrent_params *self){
            auto* v = &self->have_pieces;
            return *reinterpret_cast<libtorrent::bitfield*>(v);
        }
SWIGINTERN void libtorrent_add_torrent_params_set_have_pieces(libtorrent::add_torrent_params *self,libtorrent::bitfield &v){
            auto* t = reinterpret_cast<libtorrent::typed_bitfield<libtorrent::piece_index_t>*>(&v);
            self->have_pieces = *t;
        }
SWIGINTERN libtorrent::bitfield libtorrent_add_torrent_params_get_verified_pieces(libtorrent::add_torrent_params *self){
            auto* v = &self->verified_pieces;
            return *reinterpret_cast<libtorrent::bitfield*>(v);
        }
SWIGINTERN void libtorrent_add_torrent_params_set_verified_pieces(libtorrent::add_torrent_params *self,libtorrent::bitfield &v){
            auto* t = reinterpret_cast<libtorrent::typed_bitfield<libtorrent::piece_index_t>*>(&v);
            self->verified_pieces = *t;
        }
SWIGINTERN libtorrent::add_torrent_params libtorrent_add_torrent_params_create_instance(){
            return libtorrent::add_torrent_params();
        }
SWIGINTERN libtorrent::add_torrent_params libtorrent_add_torrent_params_read_resume_data__SWIG_0(libtorrent::bdecode_node const &rd,libtorrent::error_code &ec){
            return libtorrent::read_resume_data(rd, ec);
        }
SWIGINTERN libtorrent::add_torrent_params libtorrent_add_torrent_params_read_resume_data__SWIG_1(std::vector< int8_t > const &buffer,libtorrent::error_code &ec){
            return libtorrent::read_resume_data({(char const*)&buffer[0], static_cast<long>(buffer.size())}, ec);
        }
SWIGINTERN libtorrent::entry libtorrent_add_torrent_params_write_resume_data(libtorrent::add_torrent_params const &atp){
            return libtorrent::write_resume_data(atp);
        }
SWIGINTERN std::vector< int8_t > libtorrent_add_torrent_params_write_resume_data_buf(libtorrent::add_torrent_params const &atp){
            auto v = libtorrent::write_resume_data_buf(atp);
            return {v.begin(), v.end()};
        }
SWIGINTERN libtorrent::add_torrent_params libtorrent_add_torrent_params_parse_magnet_uri(std::string const &uri,libtorrent::error_code &ec){
            return libtorrent::parse_magnet_uri(uri, ec);
        }

#include <memory>

SWIGINTERN std::vector< int8_t > libtorrent_peer_info_get_client(libtorrent::peer_info *self){
            std::string s = self->client;
            return {s.begin(), s.end()};
        }
SWIGINTERN int64_t libtorrent_peer_info_get_last_request(libtorrent::peer_info *self){
            return libtorrent::total_milliseconds(self->last_request);
        }
SWIGINTERN int64_t libtorrent_peer_info_get_last_active(libtorrent::peer_info *self){
            return libtorrent::total_milliseconds(self->last_active);
        }
SWIGINTERN int64_t libtorrent_peer_info_get_download_queue_time(libtorrent::peer_info *self){
            return libtorrent::total_milliseconds(self->download_queue_time);
        }
SWIGINTERN std::int32_t libtorrent_peer_info_get_flags(libtorrent::peer_info *self){
            return std::int32_t(static_cast<std::uint32_t>(self->flags));
        }
SWIGINTERN std::int8_t libtorrent_peer_info_get_source(libtorrent::peer_info *self){
            return std::int8_t(static_cast<std::uint8_t>(self->source));
        }
SWIGINTERN std::int8_t libtorrent_peer_info_get_read_state(libtorrent::peer_info *self){
            return std::int8_t(static_cast<std::uint8_t>(self->read_state));
        }
SWIGINTERN std::int8_t libtorrent_peer_info_get_write_state(libtorrent::peer_info *self){
            return std::int8_t(static_cast<std::uint8_t>(self->write_state));
        }
SWIGINTERN libtorrent::bitfield libtorrent_peer_info_get_pieces(libtorrent::peer_info *self){
            auto* v = &self->pieces;
            return *reinterpret_cast<libtorrent::bitfield*>(v);
        }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::connection_type_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN void libtorrent_torrent_handle_add_piece_bytes__SWIG_0(libtorrent::torrent_handle *self,int piece,std::vector< int8_t > const &data,libtorrent::add_piece_flags_t flags={}){
            self->add_piece(piece_index_t(piece), (char const*)&data[0], flags);
        }
SWIGINTERN libtorrent::torrent_info const *libtorrent_torrent_handle_torrent_file_ptr(libtorrent::torrent_handle *self){
            return self->torrent_file().get();
        }
SWIGINTERN libtorrent::torrent_info const *libtorrent_torrent_handle_torrent_file_with_hashes_ptr(libtorrent::torrent_handle *self){
                return self->torrent_file_with_hashes().get();
        }
SWIGINTERN std::vector< std::string > libtorrent_torrent_handle_get_url_seeds(libtorrent::torrent_handle const *self){
            std::set<std::string> s = self->url_seeds();
            return {s.begin(), s.end()};
        }
SWIGINTERN std::vector< std::string > libtorrent_torrent_handle_get_http_seeds(libtorrent::torrent_handle const *self){
            std::set<std::string> s = self->http_seeds();
            return {s.begin(), s.end()};
        }
SWIGINTERN void libtorrent_torrent_handle_set_ssl_certificate_buffer2(libtorrent::torrent_handle *self,std::vector< int8_t > const &certificate,std::vector< int8_t > const &private_key,std::vector< int8_t > const &dh_params){
            std::string cert{certificate.begin(), certificate.end()};
            std::string pk{private_key.begin(), private_key.end()};
            std::string dh{dh_params.begin(), dh_params.end()};
            self->set_ssl_certificate_buffer(cert, pk, dh);
        }
SWIGINTERN int libtorrent_torrent_handle_queue_position2(libtorrent::torrent_handle const *self){
            return static_cast<int>(self->queue_position());
        }
SWIGINTERN void libtorrent_torrent_handle_queue_position_set2(libtorrent::torrent_handle *self,int p){
            self->queue_position_set(queue_position_t{p});
        }
SWIGINTERN int libtorrent_torrent_handle_piece_priority2__SWIG_0(libtorrent::torrent_handle *self,piece_index_t index){
            return int(static_cast<std::uint8_t>(self->piece_priority(index)));
        }
SWIGINTERN void libtorrent_torrent_handle_piece_priority2__SWIG_1(libtorrent::torrent_handle *self,piece_index_t index,int priority){
            self->piece_priority(index, download_priority_t{std::uint8_t(priority)});
        }
SWIGINTERN void libtorrent_torrent_handle_prioritize_pieces2__SWIG_0(libtorrent::torrent_handle *self,std::vector< int > const &pieces){
            std::vector<download_priority_t> v(pieces.size());
            for (std::size_t i = 0; i < v.size(); i++)
                v[i] = download_priority_t{std::uint8_t(pieces[i])};
            self->prioritize_pieces(v);
        }
SWIGINTERN void libtorrent_torrent_handle_prioritize_pieces2__SWIG_1(libtorrent::torrent_handle *self,std::vector< std::pair< piece_index_t,int > > const &pieces){
            std::vector<std::pair<piece_index_t, download_priority_t>> v(pieces.size());
            for (std::size_t i = 0; i < v.size(); i++)
                v[i] = std::pair<piece_index_t, download_priority_t>(pieces[i].first, download_priority_t{std::uint8_t(pieces[i].second)});
            self->prioritize_pieces(v);
        }
SWIGINTERN std::vector< int > libtorrent_torrent_handle_get_piece_priorities2(libtorrent::torrent_handle const *self){
            std::vector<download_priority_t> v = self->get_piece_priorities();
            std::vector<int> r(v.size());
            for (std::size_t i = 0; i < v.size(); i++)
                r[i] = int(static_cast<std::uint8_t>(v[i]));
            return r;
        }
SWIGINTERN int libtorrent_torrent_handle_file_priority2__SWIG_0(libtorrent::torrent_handle *self,file_index_t index){
            return int(static_cast<std::uint8_t>(self->file_priority(index)));
        }
SWIGINTERN void libtorrent_torrent_handle_file_priority2__SWIG_1(libtorrent::torrent_handle *self,file_index_t index,int priority){
            self->file_priority(index, download_priority_t{std::uint8_t(priority)});
        }
SWIGINTERN void libtorrent_torrent_handle_prioritize_files2(libtorrent::torrent_handle *self,std::vector< int > const &files){
            std::vector<download_priority_t> v(files.size());
            for (std::size_t i = 0; i < v.size(); i++)
                v[i] = download_priority_t{std::uint8_t(files[i])};
            self->prioritize_files(v);
        }
SWIGINTERN std::vector< int > libtorrent_torrent_handle_get_file_priorities2(libtorrent::torrent_handle const *self){
            std::vector<download_priority_t> v = self->get_file_priorities();
            std::vector<int> r(v.size());
            for (std::size_t i = 0; i < v.size(); i++)
                r[i] = int(static_cast<std::uint8_t>(v[i]));
            return r;
        }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::add_piece_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::deadline_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::file_progress_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::pause_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::resume_data_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::reannounce_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint32_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint32_t, libtorrent::status_flags_tag>(static_cast<std::uint32_t>(val));
                }
SWIGINTERN libtorrent::torrent_info const *libtorrent_torrent_status_torrent_file_ptr(libtorrent::torrent_status *self){
            return self->torrent_file.lock().get();
        }
SWIGINTERN int64_t libtorrent_torrent_status_get_next_announce(libtorrent::torrent_status *self){
            return libtorrent::total_milliseconds(self->next_announce);
        }
SWIGINTERN int64_t libtorrent_torrent_status_get_last_upload(libtorrent::torrent_status *self){
            return libtorrent::total_milliseconds(self->last_upload.time_since_epoch());
        }
SWIGINTERN int64_t libtorrent_torrent_status_get_last_download(libtorrent::torrent_status *self){
            return libtorrent::total_milliseconds(self->last_download.time_since_epoch());
        }
SWIGINTERN int64_t libtorrent_torrent_status_get_active_duration(libtorrent::torrent_status *self){
            return libtorrent::total_milliseconds(self->active_duration);
        }
SWIGINTERN int64_t libtorrent_torrent_status_get_finished_duration(libtorrent::torrent_status *self){
            return libtorrent::total_milliseconds(self->finished_duration);
        }
SWIGINTERN int64_t libtorrent_torrent_status_get_seeding_duration(libtorrent::torrent_status *self){
            return libtorrent::total_milliseconds(self->seeding_duration);
        }
SWIGINTERN int libtorrent_torrent_status_get_queue_position(libtorrent::torrent_status *self){
            return static_cast<int>(self->queue_position);
        }
SWIGINTERN libtorrent::bitfield libtorrent_torrent_status_get_pieces(libtorrent::torrent_status *self){
            auto* v = &self->pieces;
            return *reinterpret_cast<libtorrent::bitfield*>(v);
        }
SWIGINTERN libtorrent::bitfield libtorrent_torrent_status_get_verified_pieces(libtorrent::torrent_status *self){
            auto* v = &self->verified_pieces;
            return *reinterpret_cast<libtorrent::bitfield*>(v);
        }
SWIGINTERN libtorrent::entry &libtorrent_entry_get(libtorrent::entry *self,std::string const &key){
                return self->operator[](key);
            }
SWIGINTERN void libtorrent_entry_set__SWIG_0(libtorrent::entry *self,std::string const &key,std::string const &value){
                self->operator[](key) = value;
            }
SWIGINTERN void libtorrent_entry_set__SWIG_1(libtorrent::entry *self,std::string const &key,std::vector< int8_t > const &value){
                 self->operator[](key) = std::string(value.begin(), value.end());
            }
SWIGINTERN void libtorrent_entry_set__SWIG_2(libtorrent::entry *self,std::string const &key,long long const &value){
                self->operator[](key) = value;
            }
SWIGINTERN void libtorrent_entry_set__SWIG_3(libtorrent::entry *self,std::string const &key,libtorrent::entry const &value){
                self->operator[](key) = value;
            }
SWIGINTERN std::vector< int8_t > libtorrent_entry_string_bytes(libtorrent::entry *self){
                std::string s = self->string();
                return std::vector<int8_t>(s.begin(), s.end());
            }
SWIGINTERN std::vector< int8_t > libtorrent_entry_preformatted_bytes(libtorrent::entry *self){
                std::vector<char> v = self->preformatted();
                return std::vector<int8_t>(v.begin(), v.end());
            }
SWIGINTERN std::vector< int8_t > libtorrent_entry_bencode(libtorrent::entry *self){
                std::vector<int8_t> buffer;
                libtorrent::bencode(std::back_inserter(buffer), *self);
                return buffer;
            }
SWIGINTERN libtorrent::entry libtorrent_entry_from_string_bytes(std::vector< int8_t > const &string_bytes){
                return libtorrent::entry(std::string(string_bytes.begin(), string_bytes.end()));
            }
SWIGINTERN libtorrent::entry libtorrent_entry_from_preformatted_bytes(std::vector< int8_t > const &preformatted_bytes){
                return libtorrent::entry(std::vector<char>(preformatted_bytes.begin(), preformatted_bytes.end()));
            }
SWIGINTERN libtorrent::entry libtorrent_entry_bdecode(std::vector< int8_t > &buffer){
                return libtorrent::bdecode({reinterpret_cast<char const*>(buffer.data()), static_cast<long>(buffer.size())});
            }
SWIGINTERN int64_t libtorrent_alert_get_timestamp(libtorrent::alert *self){
            return libtorrent::total_milliseconds(self->timestamp().time_since_epoch());
        }
SWIGINTERN libtorrent::add_torrent_alert const *libtorrent_alert_cast_to_add_torrent_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::add_torrent_alert>(a); }
SWIGINTERN libtorrent::alerts_dropped_alert const *libtorrent_alert_cast_to_alerts_dropped_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::alerts_dropped_alert>(a); }
SWIGINTERN libtorrent::block_downloading_alert const *libtorrent_alert_cast_to_block_downloading_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::block_downloading_alert>(a); }
SWIGINTERN libtorrent::block_finished_alert const *libtorrent_alert_cast_to_block_finished_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::block_finished_alert>(a); }
SWIGINTERN libtorrent::block_timeout_alert const *libtorrent_alert_cast_to_block_timeout_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::block_timeout_alert>(a); }
SWIGINTERN libtorrent::block_uploaded_alert const *libtorrent_alert_cast_to_block_uploaded_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::block_uploaded_alert>(a); }
SWIGINTERN libtorrent::cache_flushed_alert const *libtorrent_alert_cast_to_cache_flushed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::cache_flushed_alert>(a); }
SWIGINTERN libtorrent::dht_announce_alert const *libtorrent_alert_cast_to_dht_announce_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_announce_alert>(a); }
SWIGINTERN libtorrent::dht_bootstrap_alert const *libtorrent_alert_cast_to_dht_bootstrap_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_bootstrap_alert>(a); }
SWIGINTERN libtorrent::dht_direct_response_alert const *libtorrent_alert_cast_to_dht_direct_response_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_direct_response_alert>(a); }
SWIGINTERN libtorrent::dht_error_alert const *libtorrent_alert_cast_to_dht_error_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_error_alert>(a); }
SWIGINTERN libtorrent::dht_get_peers_alert const *libtorrent_alert_cast_to_dht_get_peers_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_get_peers_alert>(a); }
SWIGINTERN libtorrent::dht_get_peers_reply_alert const *libtorrent_alert_cast_to_dht_get_peers_reply_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_get_peers_reply_alert>(a); }
SWIGINTERN libtorrent::dht_immutable_item_alert const *libtorrent_alert_cast_to_dht_immutable_item_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_immutable_item_alert>(a); }
SWIGINTERN libtorrent::dht_live_nodes_alert const *libtorrent_alert_cast_to_dht_live_nodes_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_live_nodes_alert>(a); }
SWIGINTERN libtorrent::dht_log_alert const *libtorrent_alert_cast_to_dht_log_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_log_alert>(a); }
SWIGINTERN libtorrent::dht_mutable_item_alert const *libtorrent_alert_cast_to_dht_mutable_item_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_mutable_item_alert>(a); }
SWIGINTERN libtorrent::dht_outgoing_get_peers_alert const *libtorrent_alert_cast_to_dht_outgoing_get_peers_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_outgoing_get_peers_alert>(a); }
SWIGINTERN libtorrent::dht_pkt_alert const *libtorrent_alert_cast_to_dht_pkt_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_pkt_alert>(a); }
SWIGINTERN libtorrent::dht_put_alert const *libtorrent_alert_cast_to_dht_put_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_put_alert>(a); }
SWIGINTERN libtorrent::dht_reply_alert const *libtorrent_alert_cast_to_dht_reply_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_reply_alert>(a); }
SWIGINTERN libtorrent::dht_sample_infohashes_alert const *libtorrent_alert_cast_to_dht_sample_infohashes_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_sample_infohashes_alert>(a); }
SWIGINTERN libtorrent::dht_stats_alert const *libtorrent_alert_cast_to_dht_stats_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::dht_stats_alert>(a); }
SWIGINTERN libtorrent::external_ip_alert const *libtorrent_alert_cast_to_external_ip_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::external_ip_alert>(a); }
SWIGINTERN libtorrent::fastresume_rejected_alert const *libtorrent_alert_cast_to_fastresume_rejected_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::fastresume_rejected_alert>(a); }
SWIGINTERN libtorrent::file_completed_alert const *libtorrent_alert_cast_to_file_completed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::file_completed_alert>(a); }
SWIGINTERN libtorrent::file_error_alert const *libtorrent_alert_cast_to_file_error_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::file_error_alert>(a); }
SWIGINTERN libtorrent::file_prio_alert const *libtorrent_alert_cast_to_file_prio_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::file_prio_alert>(a); }
SWIGINTERN libtorrent::file_progress_alert const *libtorrent_alert_cast_to_file_progress_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::file_progress_alert>(a); }
SWIGINTERN libtorrent::file_rename_failed_alert const *libtorrent_alert_cast_to_file_rename_failed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::file_rename_failed_alert>(a); }
SWIGINTERN libtorrent::file_renamed_alert const *libtorrent_alert_cast_to_file_renamed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::file_renamed_alert>(a); }
SWIGINTERN libtorrent::hash_failed_alert const *libtorrent_alert_cast_to_hash_failed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::hash_failed_alert>(a); }
SWIGINTERN libtorrent::i2p_alert const *libtorrent_alert_cast_to_i2p_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::i2p_alert>(a); }
SWIGINTERN libtorrent::incoming_connection_alert const *libtorrent_alert_cast_to_incoming_connection_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::incoming_connection_alert>(a); }
SWIGINTERN libtorrent::incoming_request_alert const *libtorrent_alert_cast_to_incoming_request_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::incoming_request_alert>(a); }
SWIGINTERN libtorrent::invalid_request_alert const *libtorrent_alert_cast_to_invalid_request_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::invalid_request_alert>(a); }
SWIGINTERN libtorrent::listen_failed_alert const *libtorrent_alert_cast_to_listen_failed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::listen_failed_alert>(a); }
SWIGINTERN libtorrent::listen_succeeded_alert const *libtorrent_alert_cast_to_listen_succeeded_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::listen_succeeded_alert>(a); }
SWIGINTERN libtorrent::log_alert const *libtorrent_alert_cast_to_log_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::log_alert>(a); }
SWIGINTERN libtorrent::lsd_error_alert const *libtorrent_alert_cast_to_lsd_error_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::lsd_error_alert>(a); }
SWIGINTERN libtorrent::lsd_peer_alert const *libtorrent_alert_cast_to_lsd_peer_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::lsd_peer_alert>(a); }
SWIGINTERN libtorrent::metadata_failed_alert const *libtorrent_alert_cast_to_metadata_failed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::metadata_failed_alert>(a); }
SWIGINTERN libtorrent::metadata_received_alert const *libtorrent_alert_cast_to_metadata_received_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::metadata_received_alert>(a); }
SWIGINTERN libtorrent::oversized_file_alert const *libtorrent_alert_cast_to_oversized_file_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::oversized_file_alert>(a); }
SWIGINTERN libtorrent::peer_ban_alert const *libtorrent_alert_cast_to_peer_ban_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::peer_ban_alert>(a); }
SWIGINTERN libtorrent::peer_blocked_alert const *libtorrent_alert_cast_to_peer_blocked_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::peer_blocked_alert>(a); }
SWIGINTERN libtorrent::peer_connect_alert const *libtorrent_alert_cast_to_peer_connect_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::peer_connect_alert>(a); }
SWIGINTERN libtorrent::peer_disconnected_alert const *libtorrent_alert_cast_to_peer_disconnected_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::peer_disconnected_alert>(a); }
SWIGINTERN libtorrent::peer_error_alert const *libtorrent_alert_cast_to_peer_error_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::peer_error_alert>(a); }
SWIGINTERN libtorrent::peer_info_alert const *libtorrent_alert_cast_to_peer_info_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::peer_info_alert>(a); }
SWIGINTERN libtorrent::peer_log_alert const *libtorrent_alert_cast_to_peer_log_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::peer_log_alert>(a); }
SWIGINTERN libtorrent::peer_snubbed_alert const *libtorrent_alert_cast_to_peer_snubbed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::peer_snubbed_alert>(a); }
SWIGINTERN libtorrent::peer_unsnubbed_alert const *libtorrent_alert_cast_to_peer_unsnubbed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::peer_unsnubbed_alert>(a); }
SWIGINTERN libtorrent::performance_alert const *libtorrent_alert_cast_to_performance_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::performance_alert>(a); }
SWIGINTERN libtorrent::picker_log_alert const *libtorrent_alert_cast_to_picker_log_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::picker_log_alert>(a); }
SWIGINTERN libtorrent::piece_availability_alert const *libtorrent_alert_cast_to_piece_availability_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::piece_availability_alert>(a); }
SWIGINTERN libtorrent::piece_finished_alert const *libtorrent_alert_cast_to_piece_finished_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::piece_finished_alert>(a); }
SWIGINTERN libtorrent::piece_info_alert const *libtorrent_alert_cast_to_piece_info_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::piece_info_alert>(a); }
SWIGINTERN libtorrent::portmap_alert const *libtorrent_alert_cast_to_portmap_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::portmap_alert>(a); }
SWIGINTERN libtorrent::portmap_error_alert const *libtorrent_alert_cast_to_portmap_error_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::portmap_error_alert>(a); }
SWIGINTERN libtorrent::portmap_log_alert const *libtorrent_alert_cast_to_portmap_log_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::portmap_log_alert>(a); }
SWIGINTERN libtorrent::read_piece_alert const *libtorrent_alert_cast_to_read_piece_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::read_piece_alert>(a); }
SWIGINTERN libtorrent::request_dropped_alert const *libtorrent_alert_cast_to_request_dropped_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::request_dropped_alert>(a); }
SWIGINTERN libtorrent::save_resume_data_alert const *libtorrent_alert_cast_to_save_resume_data_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::save_resume_data_alert>(a); }
SWIGINTERN libtorrent::save_resume_data_failed_alert const *libtorrent_alert_cast_to_save_resume_data_failed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::save_resume_data_failed_alert>(a); }
SWIGINTERN libtorrent::scrape_failed_alert const *libtorrent_alert_cast_to_scrape_failed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::scrape_failed_alert>(a); }
SWIGINTERN libtorrent::scrape_reply_alert const *libtorrent_alert_cast_to_scrape_reply_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::scrape_reply_alert>(a); }
SWIGINTERN libtorrent::session_error_alert const *libtorrent_alert_cast_to_session_error_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::session_error_alert>(a); }
SWIGINTERN libtorrent::session_stats_alert const *libtorrent_alert_cast_to_session_stats_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::session_stats_alert>(a); }
SWIGINTERN libtorrent::session_stats_header_alert const *libtorrent_alert_cast_to_session_stats_header_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::session_stats_header_alert>(a); }
SWIGINTERN libtorrent::socks5_alert const *libtorrent_alert_cast_to_socks5_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::socks5_alert>(a); }
SWIGINTERN libtorrent::state_changed_alert const *libtorrent_alert_cast_to_state_changed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::state_changed_alert>(a); }
SWIGINTERN libtorrent::state_update_alert const *libtorrent_alert_cast_to_state_update_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::state_update_alert>(a); }
SWIGINTERN libtorrent::storage_moved_alert const *libtorrent_alert_cast_to_storage_moved_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::storage_moved_alert>(a); }
SWIGINTERN libtorrent::storage_moved_failed_alert const *libtorrent_alert_cast_to_storage_moved_failed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::storage_moved_failed_alert>(a); }
SWIGINTERN libtorrent::torrent_checked_alert const *libtorrent_alert_cast_to_torrent_checked_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::torrent_checked_alert>(a); }
SWIGINTERN libtorrent::torrent_conflict_alert const *libtorrent_alert_cast_to_torrent_conflict_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::torrent_conflict_alert>(a); }
SWIGINTERN libtorrent::torrent_delete_failed_alert const *libtorrent_alert_cast_to_torrent_delete_failed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::torrent_delete_failed_alert>(a); }
SWIGINTERN libtorrent::torrent_deleted_alert const *libtorrent_alert_cast_to_torrent_deleted_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::torrent_deleted_alert>(a); }
SWIGINTERN libtorrent::torrent_error_alert const *libtorrent_alert_cast_to_torrent_error_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::torrent_error_alert>(a); }
SWIGINTERN libtorrent::torrent_finished_alert const *libtorrent_alert_cast_to_torrent_finished_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::torrent_finished_alert>(a); }
SWIGINTERN libtorrent::torrent_log_alert const *libtorrent_alert_cast_to_torrent_log_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::torrent_log_alert>(a); }
SWIGINTERN libtorrent::torrent_need_cert_alert const *libtorrent_alert_cast_to_torrent_need_cert_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::torrent_need_cert_alert>(a); }
SWIGINTERN libtorrent::torrent_paused_alert const *libtorrent_alert_cast_to_torrent_paused_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::torrent_paused_alert>(a); }
SWIGINTERN libtorrent::torrent_removed_alert const *libtorrent_alert_cast_to_torrent_removed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::torrent_removed_alert>(a); }
SWIGINTERN libtorrent::torrent_resumed_alert const *libtorrent_alert_cast_to_torrent_resumed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::torrent_resumed_alert>(a); }
SWIGINTERN libtorrent::tracker_announce_alert const *libtorrent_alert_cast_to_tracker_announce_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::tracker_announce_alert>(a); }
SWIGINTERN libtorrent::tracker_error_alert const *libtorrent_alert_cast_to_tracker_error_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::tracker_error_alert>(a); }
SWIGINTERN libtorrent::tracker_list_alert const *libtorrent_alert_cast_to_tracker_list_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::tracker_list_alert>(a); }
SWIGINTERN libtorrent::tracker_reply_alert const *libtorrent_alert_cast_to_tracker_reply_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::tracker_reply_alert>(a); }
SWIGINTERN libtorrent::tracker_warning_alert const *libtorrent_alert_cast_to_tracker_warning_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::tracker_warning_alert>(a); }
SWIGINTERN libtorrent::trackerid_alert const *libtorrent_alert_cast_to_trackerid_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::trackerid_alert>(a); }
SWIGINTERN libtorrent::udp_error_alert const *libtorrent_alert_cast_to_udp_error_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::udp_error_alert>(a); }
SWIGINTERN libtorrent::unwanted_block_alert const *libtorrent_alert_cast_to_unwanted_block_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::unwanted_block_alert>(a); }
SWIGINTERN libtorrent::url_seed_alert const *libtorrent_alert_cast_to_url_seed_alert(libtorrent::alert const *a){ return libtorrent::alert_cast<libtorrent::url_seed_alert>(a); }
SWIGINTERN libtorrent::tcp::endpoint libtorrent_peer_alert_get_endpoint(libtorrent::peer_alert *self){
            return self->endpoint;
        }
SWIGINTERN libtorrent::tcp::endpoint libtorrent_tracker_alert_get_local_endpoint(libtorrent::tracker_alert *self){
            return self->local_endpoint;
        }
SWIGINTERN int64_t libtorrent_read_piece_alert_buffer_ptr(libtorrent::read_piece_alert *self){
            return reinterpret_cast<int64_t>(self->buffer.get());
        }
SWIGINTERN libtorrent::udp::endpoint libtorrent_udp_error_alert_get_endpoint(libtorrent::udp_error_alert *self){
            return self->endpoint;
        }
SWIGINTERN libtorrent::address libtorrent_external_ip_alert_get_external_address(libtorrent::external_ip_alert *self){
            return self->external_address;
        }
SWIGINTERN int libtorrent_listen_failed_alert_get_socket_type(libtorrent::listen_failed_alert *self){
            return static_cast<int>(self->socket_type);
        }
SWIGINTERN libtorrent::address libtorrent_listen_failed_alert_get_address(libtorrent::listen_failed_alert *self){
            return self->address;
        }
SWIGINTERN libtorrent::address libtorrent_listen_succeeded_alert_get_address(libtorrent::listen_succeeded_alert *self){
            return self->address;
        }
SWIGINTERN int libtorrent_listen_succeeded_alert_get_socket_type(libtorrent::listen_succeeded_alert *self){
            return static_cast<int>(self->socket_type);
        }
SWIGINTERN int libtorrent_portmap_error_alert_get_mapping(libtorrent::portmap_error_alert *self){
            return static_cast<int>(self->mapping);
        }
SWIGINTERN int libtorrent_portmap_alert_get_mapping(libtorrent::portmap_alert *self){
            return static_cast<int>(self->mapping);
        }
SWIGINTERN libtorrent::address libtorrent_dht_announce_alert_get_ip(libtorrent::dht_announce_alert *self){
            return self->ip;
        }
SWIGINTERN libtorrent::tcp::endpoint libtorrent_incoming_connection_alert_get_endpoint(libtorrent::incoming_connection_alert *self){
            return self->endpoint;
        }
SWIGINTERN long long libtorrent_session_stats_alert_get_value(libtorrent::session_stats_alert *self,int index){
            return self->counters()[index];
        }
SWIGINTERN std::vector< int8_t > libtorrent_dht_mutable_item_alert_get_key(libtorrent::dht_mutable_item_alert *self){
            std::array<char, 32> arr = self->key;
            return std::vector<int8_t>(arr.begin(), arr.end());
        }
SWIGINTERN std::vector< int8_t > libtorrent_dht_mutable_item_alert_get_signature(libtorrent::dht_mutable_item_alert *self){
            std::array<char, 64> arr = self->signature;
            return std::vector<int8_t>(arr.begin(), arr.end());
        }
SWIGINTERN int64_t libtorrent_dht_mutable_item_alert_get_seq(libtorrent::dht_mutable_item_alert *self){
            return int64_t(self->seq);
        }
SWIGINTERN std::vector< int8_t > libtorrent_dht_mutable_item_alert_get_salt(libtorrent::dht_mutable_item_alert *self){
            std::string s = self->salt;
            return std::vector<int8_t>(s.begin(), s.end());
        }
SWIGINTERN std::array< std::int8_t,32 > libtorrent_dht_put_alert_get_public_key(libtorrent::dht_put_alert *self){
            std::array<char, 32> arr = self->public_key;
            return *reinterpret_cast<std::array<std::int8_t, 32>*>(&arr);
        }
SWIGINTERN std::array< std::int8_t,64 > libtorrent_dht_put_alert_get_signature(libtorrent::dht_put_alert *self){
            std::array<char, 64> arr = self->signature;
            return *reinterpret_cast<std::array<std::int8_t, 64>*>(&arr);
        }
SWIGINTERN std::vector< std::int8_t > libtorrent_dht_put_alert_get_salt(libtorrent::dht_put_alert *self){
            std::string s = self->salt;
            return std::vector<std::int8_t>(s.begin(), s.end());
        }
SWIGINTERN int64_t libtorrent_dht_put_alert_get_seq(libtorrent::dht_put_alert *self){
            return int64_t(self->seq);
        }
SWIGINTERN libtorrent::udp::endpoint libtorrent_dht_outgoing_get_peers_alert_get_endpoint(libtorrent::dht_outgoing_get_peers_alert *self){
            return self->endpoint;
        }
SWIGINTERN std::string libtorrent_peer_log_alert_get_event_type(libtorrent::peer_log_alert *self){
            return std::string(self->event_type);
        }
SWIGINTERN std::string libtorrent_dht_lookup_get_type(libtorrent::dht_lookup *self){
            return std::string(self->type);
        }
SWIGINTERN libtorrent::udp::endpoint libtorrent_dht_stats_alert_get_local_endpoint(libtorrent::dht_stats_alert *self){
            return self->local_endpoint;
        }
SWIGINTERN libtorrent::udp::endpoint libtorrent_dht_pkt_alert_get_node(libtorrent::dht_pkt_alert *self){
            return self->node;
        }
SWIGINTERN std::vector< std::int8_t > libtorrent_dht_pkt_alert_get_pkt_buf(libtorrent::dht_pkt_alert *self){
            auto buf = self->pkt_buf();
            return {buf.begin(), buf.end()};
        }
SWIGINTERN libtorrent::client_data_t libtorrent_dht_direct_response_alert_get_userdata(libtorrent::dht_direct_response_alert *self){
           return self->userdata;
       }
SWIGINTERN libtorrent::udp::endpoint libtorrent_dht_direct_response_alert_get_endpoint(libtorrent::dht_direct_response_alert *self){
            return self->endpoint;
        }
SWIGINTERN libtorrent::udp::endpoint libtorrent_dht_sample_infohashes_alert_get_endpoint(libtorrent::dht_sample_infohashes_alert *self){
            return self->endpoint;
        }
SWIGINTERN std::int64_t libtorrent_dht_sample_infohashes_alert_get_interval(libtorrent::dht_sample_infohashes_alert *self){
            return libtorrent::total_milliseconds(self->interval);
        }
SWIGINTERN libtorrent::torrent_info libtorrent_torrent_conflict_alert_get_metadata(libtorrent::torrent_conflict_alert *self){
            return *(self->metadata);
        }
SWIGINTERN std::vector< std::int64_t > libtorrent_file_progress_alert_get_files(libtorrent::file_progress_alert *self){
            auto* v = &self->files;
            return *reinterpret_cast<std::vector<std::int64_t>*>(v);
        }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *self){
                    return static_cast<int>(static_cast<std::uint32_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint32_t, libtorrent::alert_category_tag>(static_cast<std::uint32_t>(val));
                }
SWIGINTERN std::vector< std::int8_t > libtorrent_settings_pack_get_bytes(libtorrent::settings_pack *self,int name){
            auto v = self->get_str(name);
            return std::vector<std::int8_t>(v.begin(), v.end());
        }
SWIGINTERN void libtorrent_settings_pack_set_bytes(libtorrent::settings_pack *self,int name,std::vector< std::int8_t > v){
            self->set_str(name, std::string(v.begin(), v.end()));
        }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::remove_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint32_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint32_t, libtorrent::save_state_flags_tag>(static_cast<std::uint32_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::session_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__non_zero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__nonZero(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *self){
                    return self->operator bool();
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__eq(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const f){
                    return self->operator==(f);
                }
SWIGINTERN bool libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__ne(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const f){
                    return self->operator!=(f);
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__or_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const other){
                    return *self | other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__and_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const other){
                    return *self & other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__xor_(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *self,libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const other){
                    return *self ^ other;
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__inv(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *self){
                    return self->operator~();
                }
SWIGINTERN int libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__to_int(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *self){
                    return static_cast<int>(static_cast<std::uint8_t>(*self));
                }
SWIGINTERN libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__from_int(int val){
                    return libtorrent::flags::bitfield_flag<std::uint8_t, libtorrent::reopen_network_flags_tag>(static_cast<std::uint8_t>(val));
                }
SWIGINTERN libtorrent::session_params libtorrent_session_params_read_session_params__SWIG_0(libtorrent::bdecode_node const &e,libtorrent::save_state_flags_t flags=libtorrent::save_state_flags_t::all()){
            return libtorrent::read_session_params(e, flags);
        }
SWIGINTERN libtorrent::entry libtorrent_session_params_write_session_params__SWIG_0(libtorrent::session_params const &sp,libtorrent::save_state_flags_t flags=libtorrent::save_state_flags_t::all()){
            return libtorrent::write_session_params(sp, flags);
        }
SWIGINTERN std::vector< std::int8_t > libtorrent_session_params_write_session_params_buf__SWIG_0(libtorrent::session_params const &sp,libtorrent::save_state_flags_t flags=libtorrent::save_state_flags_t::all()){
            auto v = libtorrent::write_session_params_buf(sp, flags);
            return {v.begin(), v.end()};
        }
SWIGINTERN void libtorrent_session_params_set_posix_disk_io_constructor(libtorrent::session_params *self){
            self->disk_io_constructor = libtorrent::posix_disk_io_constructor;
        }
SWIGINTERN void libtorrent_session_params_set_default_disk_io_constructor(libtorrent::session_params *self){
            self->disk_io_constructor = libtorrent::default_disk_io_constructor;
        }
SWIGINTERN void libtorrent_session_handle_dht_get_item__SWIG_1(libtorrent::session_handle *self,std::vector< std::int8_t > &key,std::vector< std::int8_t > &salt){
            if (key.size() != 32) {
                throw std::invalid_argument("Public key must be of size 32");
            }
            std::array<char, 32> pk;
            std::copy_n(key.begin(), 32, pk.begin());

            self->dht_get_item(pk, std::string(salt.begin(), salt.end()));
        }
SWIGINTERN void libtorrent_session_handle_dht_get_item__SWIG_2(libtorrent::session_handle *self,std::array< std::int8_t,32 > &key,std::vector< std::int8_t > &salt){
            std::array<char, 32> pk;
            std::copy_n(key.begin(), 32, pk.begin());

            self->dht_get_item(pk, std::string(salt.begin(), salt.end()));
        }
SWIGINTERN void libtorrent_session_handle_dht_put_item__SWIG_1(libtorrent::session_handle *self,std::vector< std::int8_t > &key,std::vector< std::int8_t > &sk,libtorrent::entry &data,std::vector< std::int8_t > &salt){
            if (key.size() != 32) {
                throw std::invalid_argument("Public key must be of size 32");
            }
            if (sk.size() != 64) {
                throw std::invalid_argument("Private key must be of size 64");
            }
            std::array<char, 32> pk;
            std::copy_n(key.begin(), 32, pk.begin());

            using namespace std::placeholders;
            using namespace libtorrent::dht;

            self->dht_put_item(pk, std::bind(&dht_put_item_cb, _1, _2, _3, _4,
                public_key((char*)key.data()), secret_key((char*)sk.data()), data),
                std::string(salt.begin(), salt.end()));
        }
SWIGINTERN void libtorrent_session_handle_dht_put_item__SWIG_2(libtorrent::session_handle *self,std::array< std::int8_t,32 > &key,std::array< std::int8_t,64 > &sk,libtorrent::entry &data,std::vector< int8_t > &salt){
            std::array<char, 32> pk;
            std::copy_n(key.begin(), 32, pk.begin());

            using namespace std::placeholders;
            using namespace libtorrent::dht;

            self->dht_put_item(pk, std::bind(&dht_put_item_cb, _1, _2, _3, _4,
                public_key((char*)key.data()), secret_key((char*)sk.data()), data),
                std::string(salt.begin(), salt.end()));
        }
SWIGINTERN void libtorrent_session_handle_dht_direct_request__SWIG_2(libtorrent::session_handle *self,libtorrent::udp::endpoint const &ep,libtorrent::entry const &e,int64_t userdata){
            self->dht_direct_request(ep, e, libtorrent::client_data_t{(void*)userdata});
        }
SWIGINTERN libtorrent::alert *libtorrent_session_handle_wait_for_alert_ms(libtorrent::session_handle *self,std::int64_t max_wait){
            return self->wait_for_alert(libtorrent::milliseconds(max_wait));
        }
SWIGINTERN void libtorrent_session_handle_set_alert_notify_callback(libtorrent::session_handle *self,alert_notify_callback *cb){
            self->set_alert_notify(std::bind(&alert_notify_callback::on_alert, cb));
        }
SWIGINTERN void libtorrent_session_handle_dht_announce_ex__SWIG_0(libtorrent::session_handle *self,libtorrent::sha1_hash const &info_hash,int port=0,std::int8_t flags={}){
            self->dht_announce(info_hash, port, libtorrent::dht::announce_flags_t{static_cast<std::uint8_t>(flags)});
        }
SWIGINTERN std::vector< int > libtorrent_session_handle_add_port_mapping_ex(libtorrent::session_handle *self,libtorrent::portmap_protocol t,int external_port,int local_port){
            auto mapping = self->add_port_mapping(t, external_port, local_port);
            std::vector<int> r;
            for (auto m : mapping)
                r.push_back(static_cast<int>(m));
            return r;
        }
SWIGINTERN void libtorrent_session_handle_delete_port_mapping_ex(libtorrent::session_handle *self,int handle){
            self->delete_port_mapping(libtorrent::port_mapping_t{handle});
        }
SWIGINTERN void libtorrent_create_torrent_add_url_seed(libtorrent::create_torrent *self,std::string const &url){
            self->add_url_seed(url);
        }
SWIGINTERN void libtorrent_create_torrent_add_http_seed(libtorrent::create_torrent *self,std::string const &url){
            self->add_http_seed(url);
        }
SWIGINTERN void libtorrent_create_torrent_add_tracker__SWIG_0(libtorrent::create_torrent *self,std::string const &url){
            self->add_tracker(url);
        }
SWIGINTERN void libtorrent_create_torrent_add_tracker__SWIG_1(libtorrent::create_torrent *self,std::string const &url,int tier){
            self->add_tracker(url, tier);
        }
SWIGINTERN void libtorrent_create_torrent_add_collection(libtorrent::create_torrent *self,std::string const &c){
            self->add_collection(c);
        }
SWIGINTERN void libtorrent_create_torrent_set_root_cert2(libtorrent::create_torrent *self,std::vector< std::int8_t > const &pem){
            std::string s{pem.begin(), pem.end()};
            self->set_root_cert(s);
        }
SWIGINTERN void libtorrent_create_torrent_set_hash2(libtorrent::create_torrent *self,file_index_t file,int piece,libtorrent::sha256_hash const &h){
            self->set_hash2(file, libtorrent::piece_index_t::diff_type{piece}, h);
        }
SWIGINTERN std::string libtorrent_stats_metric_get_name(libtorrent::stats_metric *self){
            return std::string(self->name);
        }
SWIGINTERN std::vector< int8_t > libtorrent_bloom_filter_Sl_128_Sg__to_bytes(libtorrent::bloom_filter< 128 > const *self){
                std::string s = self->to_string();
                return std::vector<int8_t>(s.begin(), s.end());
            }
SWIGINTERN void libtorrent_bloom_filter_Sl_128_Sg__from_bytes(libtorrent::bloom_filter< 128 > *self,std::vector< int8_t > const &v){
                self->from_string(reinterpret_cast<char const*>(&v[0]));
            }
SWIGINTERN std::vector< int8_t > libtorrent_bloom_filter_Sl_256_Sg__to_bytes(libtorrent::bloom_filter< 256 > const *self){
                std::string s = self->to_string();
                return std::vector<int8_t>(s.begin(), s.end());
            }
SWIGINTERN void libtorrent_bloom_filter_Sl_256_Sg__from_bytes(libtorrent::bloom_filter< 256 > *self,std::vector< int8_t > const &v){
                self->from_string(reinterpret_cast<char const*>(&v[0]));
            }
SWIGINTERN int64_t libtorrent_peer_connection_handle_get_time_of_last_unchoke(libtorrent::peer_connection_handle *self){
            return libtorrent::total_milliseconds(self->time_of_last_unchoke() - libtorrent::clock_type::now());
        }
SWIGINTERN std::vector< int8_t > libtorrent_string_view_to_bytes(libtorrent::string_view *self){
                std::string s = self->to_string();
                return std::vector<int8_t>(s.begin(), s.end());
            }


/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "libtorrent_jni.h"

SwigDirector_alert_notify_callback::SwigDirector_alert_notify_callback(JNIEnv *jenv) : alert_notify_callback(), Swig::Director(jenv) {
}

SwigDirector_alert_notify_callback::~SwigDirector_alert_notify_callback() {
  swig_disconnect_director_self("swigDirectorDisconnect");
}


void SwigDirector_alert_notify_callback::on_alert() {
  JNIEnvWrapper swigjnienv(this) ;
  JNIEnv * jenv = swigjnienv.getJNIEnv() ;
  jobject swigjobj = (jobject) NULL ;
  
  if (!swig_override[0]) {
    alert_notify_callback::on_alert();
    return;
  }
  swigjobj = swig_get_self(jenv);
  if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
    jenv->CallStaticVoidMethod(Swig::jclass_libtorrent_jni, Swig::director_method_ids[0], swigjobj);
    jthrowable swigerror = jenv->ExceptionOccurred();
    if (swigerror) {
      Swig::DirectorException::raise(jenv, swigerror);
    }
    
  } else {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in alert_notify_callback::on_alert ");
  }
  if (swigjobj) jenv->DeleteLocalRef(swigjobj);
}

void SwigDirector_alert_notify_callback::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
  static jclass baseclass = swig_new_global_ref(jenv, "com/frostwire/jlibtorrent/swig/alert_notify_callback");
  if (!baseclass) return;
  static SwigDirectorMethod methods[] = {
    SwigDirectorMethod(jenv, baseclass, "on_alert", "()V")
  };
  
  if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
    bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
    for (int i = 0; i < 1; ++i) {
      swig_override[i] = false;
      if (derived) {
        jmethodID methid = jenv->GetMethodID(jcls, methods[i].name, methods[i].desc);
        swig_override[i] = methods[i].methid && (methid != methods[i].methid);
        jenv->ExceptionClear();
      }
    }
  }
}


SwigDirector_add_files_listener::SwigDirector_add_files_listener(JNIEnv *jenv) : add_files_listener(), Swig::Director(jenv) {
}

SwigDirector_add_files_listener::~SwigDirector_add_files_listener() {
  swig_disconnect_director_self("swigDirectorDisconnect");
}


bool SwigDirector_add_files_listener::pred(std::string const &p) {
  bool c_result = SwigValueInit< bool >() ;
  jboolean jresult = 0 ;
  JNIEnvWrapper swigjnienv(this) ;
  JNIEnv * jenv = swigjnienv.getJNIEnv() ;
  jobject swigjobj = (jobject) NULL ;
  jstring jp = 0 ;
  
  if (!swig_override[0]) {
    return add_files_listener::pred(p);
  }
  swigjobj = swig_get_self(jenv);
  if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
    jp = jenv->NewStringUTF((&p)->c_str());
    Swig::LocalRefGuard p_refguard(jenv, jp); 
    jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_libtorrent_jni, Swig::director_method_ids[1], swigjobj, jp);
    jthrowable swigerror = jenv->ExceptionOccurred();
    if (swigerror) {
      Swig::DirectorException::raise(jenv, swigerror);
    }
    
    c_result = jresult ? true : false; 
  } else {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in add_files_listener::pred ");
  }
  if (swigjobj) jenv->DeleteLocalRef(swigjobj);
  return c_result;
}

void SwigDirector_add_files_listener::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
  static jclass baseclass = swig_new_global_ref(jenv, "com/frostwire/jlibtorrent/swig/add_files_listener");
  if (!baseclass) return;
  static SwigDirectorMethod methods[] = {
    SwigDirectorMethod(jenv, baseclass, "pred", "(Ljava/lang/String;)Z")
  };
  
  if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
    bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
    for (int i = 0; i < 1; ++i) {
      swig_override[i] = false;
      if (derived) {
        jmethodID methid = jenv->GetMethodID(jcls, methods[i].name, methods[i].desc);
        swig_override[i] = methods[i].methid && (methid != methods[i].methid);
        jenv->ExceptionClear();
      }
    }
  }
}


SwigDirector_set_piece_hashes_listener::SwigDirector_set_piece_hashes_listener(JNIEnv *jenv) : set_piece_hashes_listener(), Swig::Director(jenv) {
}

SwigDirector_set_piece_hashes_listener::~SwigDirector_set_piece_hashes_listener() {
  swig_disconnect_director_self("swigDirectorDisconnect");
}


void SwigDirector_set_piece_hashes_listener::progress(int i) {
  JNIEnvWrapper swigjnienv(this) ;
  JNIEnv * jenv = swigjnienv.getJNIEnv() ;
  jobject swigjobj = (jobject) NULL ;
  jint ji  ;
  
  if (!swig_override[0]) {
    set_piece_hashes_listener::progress(i);
    return;
  }
  swigjobj = swig_get_self(jenv);
  if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
    ji = (jint) i;
    jenv->CallStaticVoidMethod(Swig::jclass_libtorrent_jni, Swig::director_method_ids[2], swigjobj, ji);
    jthrowable swigerror = jenv->ExceptionOccurred();
    if (swigerror) {
      Swig::DirectorException::raise(jenv, swigerror);
    }
    
  } else {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in set_piece_hashes_listener::progress ");
  }
  if (swigjobj) jenv->DeleteLocalRef(swigjobj);
}

void SwigDirector_set_piece_hashes_listener::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
  static jclass baseclass = swig_new_global_ref(jenv, "com/frostwire/jlibtorrent/swig/set_piece_hashes_listener");
  if (!baseclass) return;
  static SwigDirectorMethod methods[] = {
    SwigDirectorMethod(jenv, baseclass, "progress", "(I)V")
  };
  
  if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
    bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
    for (int i = 0; i < 1; ++i) {
      swig_override[i] = false;
      if (derived) {
        jmethodID methid = jenv->GetMethodID(jcls, methods[i].name, methods[i].desc);
        swig_override[i] = methods[i].methid && (methid != methods[i].methid);
        jenv->ExceptionClear();
      }
    }
  }
}


SwigDirector_posix_wrapper::SwigDirector_posix_wrapper(JNIEnv *jenv) : posix_wrapper(), Swig::Director(jenv) {
}

SwigDirector_posix_wrapper::~SwigDirector_posix_wrapper() {
  swig_disconnect_director_self("swigDirectorDisconnect");
}


int SwigDirector_posix_wrapper::open(char const *path,int flags,int mode) {
  int c_result = SwigValueInit< int >() ;
  jint jresult = 0 ;
  JNIEnvWrapper swigjnienv(this) ;
  JNIEnv * jenv = swigjnienv.getJNIEnv() ;
  jobject swigjobj = (jobject) NULL ;
  jstring jpath = 0 ;
  jint jflags  ;
  jint jmode  ;
  
  if (!swig_override[0]) {
    return posix_wrapper::open(path,flags,mode);
  }
  swigjobj = swig_get_self(jenv);
  if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
    jpath = 0;
    if (path) {
      jpath = jenv->NewStringUTF((const char *)path);
      if (!jpath) return c_result;
    }
    Swig::LocalRefGuard path_refguard(jenv, jpath);
    jflags = (jint) flags;
    jmode = (jint) mode;
    jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_libtorrent_jni, Swig::director_method_ids[3], swigjobj, jpath, jflags, jmode);
    jthrowable swigerror = jenv->ExceptionOccurred();
    if (swigerror) {
      Swig::DirectorException::raise(jenv, swigerror);
    }
    
    c_result = (int)jresult; 
  } else {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in posix_wrapper::open ");
  }
  if (swigjobj) jenv->DeleteLocalRef(swigjobj);
  return c_result;
}

int SwigDirector_posix_wrapper::stat(char const *path,posix_stat_t *buf) {
  int c_result = SwigValueInit< int >() ;
  jint jresult = 0 ;
  JNIEnvWrapper swigjnienv(this) ;
  JNIEnv * jenv = swigjnienv.getJNIEnv() ;
  jobject swigjobj = (jobject) NULL ;
  jstring jpath = 0 ;
  jlong jbuf = 0 ;
  
  if (!swig_override[1]) {
    return posix_wrapper::stat(path,buf);
  }
  swigjobj = swig_get_self(jenv);
  if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
    jpath = 0;
    if (path) {
      jpath = jenv->NewStringUTF((const char *)path);
      if (!jpath) return c_result;
    }
    Swig::LocalRefGuard path_refguard(jenv, jpath);
    *((posix_stat_t **)&jbuf) = (posix_stat_t *) buf; 
    jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_libtorrent_jni, Swig::director_method_ids[4], swigjobj, jpath, jbuf);
    jthrowable swigerror = jenv->ExceptionOccurred();
    if (swigerror) {
      Swig::DirectorException::raise(jenv, swigerror);
    }
    
    c_result = (int)jresult; 
  } else {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in posix_wrapper::stat ");
  }
  if (swigjobj) jenv->DeleteLocalRef(swigjobj);
  return c_result;
}

int SwigDirector_posix_wrapper::mkdir(char const *path,int mode) {
  int c_result = SwigValueInit< int >() ;
  jint jresult = 0 ;
  JNIEnvWrapper swigjnienv(this) ;
  JNIEnv * jenv = swigjnienv.getJNIEnv() ;
  jobject swigjobj = (jobject) NULL ;
  jstring jpath = 0 ;
  jint jmode  ;
  
  if (!swig_override[2]) {
    return posix_wrapper::mkdir(path,mode);
  }
  swigjobj = swig_get_self(jenv);
  if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
    jpath = 0;
    if (path) {
      jpath = jenv->NewStringUTF((const char *)path);
      if (!jpath) return c_result;
    }
    Swig::LocalRefGuard path_refguard(jenv, jpath);
    jmode = (jint) mode;
    jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_libtorrent_jni, Swig::director_method_ids[5], swigjobj, jpath, jmode);
    jthrowable swigerror = jenv->ExceptionOccurred();
    if (swigerror) {
      Swig::DirectorException::raise(jenv, swigerror);
    }
    
    c_result = (int)jresult; 
  } else {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in posix_wrapper::mkdir ");
  }
  if (swigjobj) jenv->DeleteLocalRef(swigjobj);
  return c_result;
}

int SwigDirector_posix_wrapper::rename(char const *oldpath,char const *newpath) {
  int c_result = SwigValueInit< int >() ;
  jint jresult = 0 ;
  JNIEnvWrapper swigjnienv(this) ;
  JNIEnv * jenv = swigjnienv.getJNIEnv() ;
  jobject swigjobj = (jobject) NULL ;
  jstring joldpath = 0 ;
  jstring jnewpath = 0 ;
  
  if (!swig_override[3]) {
    return posix_wrapper::rename(oldpath,newpath);
  }
  swigjobj = swig_get_self(jenv);
  if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
    joldpath = 0;
    if (oldpath) {
      joldpath = jenv->NewStringUTF((const char *)oldpath);
      if (!joldpath) return c_result;
    }
    Swig::LocalRefGuard oldpath_refguard(jenv, joldpath);
    jnewpath = 0;
    if (newpath) {
      jnewpath = jenv->NewStringUTF((const char *)newpath);
      if (!jnewpath) return c_result;
    }
    Swig::LocalRefGuard newpath_refguard(jenv, jnewpath);
    jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_libtorrent_jni, Swig::director_method_ids[6], swigjobj, joldpath, jnewpath);
    jthrowable swigerror = jenv->ExceptionOccurred();
    if (swigerror) {
      Swig::DirectorException::raise(jenv, swigerror);
    }
    
    c_result = (int)jresult; 
  } else {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in posix_wrapper::rename ");
  }
  if (swigjobj) jenv->DeleteLocalRef(swigjobj);
  return c_result;
}

int SwigDirector_posix_wrapper::remove(char const *path) {
  int c_result = SwigValueInit< int >() ;
  jint jresult = 0 ;
  JNIEnvWrapper swigjnienv(this) ;
  JNIEnv * jenv = swigjnienv.getJNIEnv() ;
  jobject swigjobj = (jobject) NULL ;
  jstring jpath = 0 ;
  
  if (!swig_override[4]) {
    return posix_wrapper::remove(path);
  }
  swigjobj = swig_get_self(jenv);
  if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
    jpath = 0;
    if (path) {
      jpath = jenv->NewStringUTF((const char *)path);
      if (!jpath) return c_result;
    }
    Swig::LocalRefGuard path_refguard(jenv, jpath);
    jresult = (jint) jenv->CallStaticIntMethod(Swig::jclass_libtorrent_jni, Swig::director_method_ids[7], swigjobj, jpath);
    jthrowable swigerror = jenv->ExceptionOccurred();
    if (swigerror) {
      Swig::DirectorException::raise(jenv, swigerror);
    }
    
    c_result = (int)jresult; 
  } else {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null upcall object in posix_wrapper::remove ");
  }
  if (swigjobj) jenv->DeleteLocalRef(swigjobj);
  return c_result;
}

void SwigDirector_posix_wrapper::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
  static jclass baseclass = swig_new_global_ref(jenv, "com/frostwire/jlibtorrent/swig/posix_wrapper");
  if (!baseclass) return;
  static SwigDirectorMethod methods[] = {
    SwigDirectorMethod(jenv, baseclass, "open", "(Ljava/lang/String;II)I"),
    SwigDirectorMethod(jenv, baseclass, "stat", "(Ljava/lang/String;Lcom/frostwire/jlibtorrent/swig/posix_stat_t;)I"),
    SwigDirectorMethod(jenv, baseclass, "mkdir", "(Ljava/lang/String;I)I"),
    SwigDirectorMethod(jenv, baseclass, "rename", "(Ljava/lang/String;Ljava/lang/String;)I"),
    SwigDirectorMethod(jenv, baseclass, "remove", "(Ljava/lang/String;)I")
  };
  
  if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
    bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
    for (int i = 0; i < 5; ++i) {
      swig_override[i] = false;
      if (derived) {
        jmethodID methid = jenv->GetMethodID(jcls, methods[i].name, methods[i].desc);
        swig_override[i] = methods[i].methid && (methid != methods[i].methid);
        jenv->ExceptionClear();
      }
    }
  }
}



#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1byte_1pair_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::pair< int,std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< int,std::int8_t > *)new std::pair< int,std::int8_t >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< int,std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1byte_1pair_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1, jbyte jarg2) {
  jlong jresult = 0 ;
  int arg1 ;
  std::int8_t arg2 ;
  std::pair< int,std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  arg2 = (std::int8_t)jarg2; 
  {
    try {
      result = (std::pair< int,std::int8_t > *)new std::pair< int,std::int8_t >(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< int,std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1byte_1pair_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< int,std::int8_t > *arg1 = 0 ;
  std::pair< int,std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< int,std::int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< int,std::int8_t > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< int,std::int8_t > *)new std::pair< int,std::int8_t >((std::pair< int,std::int8_t > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< int,std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1first_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::pair< int,std::int8_t > *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< int,std::int8_t > **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->first = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1first_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::pair< int,std::int8_t > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< int,std::int8_t > **)&jarg1; 
  result = (int) ((arg1)->first);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1second_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jbyte jarg2) {
  std::pair< int,std::int8_t > *arg1 = 0 ;
  std::int8_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< int,std::int8_t > **)&jarg1; 
  arg2 = (std::int8_t)jarg2; 
  if (arg1) (arg1)->second = arg2;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1second_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jbyte jresult = 0 ;
  std::pair< int,std::int8_t > *arg1 = 0 ;
  std::int8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< int,std::int8_t > **)&jarg1; 
  result = (std::int8_t) ((arg1)->second);
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1int_1byte_1pair(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::pair< int,std::int8_t > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< int,std::int8_t > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1int_1pair_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::pair< std::string,int > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< std::string,int > *)new std::pair< std::string,int >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< std::string,int > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1int_1pair_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2) {
  jlong jresult = 0 ;
  std::string arg1 ;
  int arg2 ;
  std::pair< std::string,int > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = (int)jarg2; 
  {
    try {
      result = (std::pair< std::string,int > *)new std::pair< std::string,int >(SWIG_STD_MOVE(arg1),arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< std::string,int > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1int_1pair_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< std::string,int > *arg1 = 0 ;
  std::pair< std::string,int > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::string,int > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< std::string,int > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< std::string,int > *)new std::pair< std::string,int >((std::pair< std::string,int > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< std::string,int > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1first_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  std::pair< std::string,int > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::string,int > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->first = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1first_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::pair< std::string,int > *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::string,int > **)&jarg1; 
  result = (std::string *) & ((arg1)->first);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1second_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::pair< std::string,int > *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::string,int > **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->second = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1second_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::pair< std::string,int > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::string,int > **)&jarg1; 
  result = (int) ((arg1)->second);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1int_1pair(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::pair< std::string,int > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< std::string,int > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1string_1pair_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::pair< std::string,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< std::string,std::string > *)new std::pair< std::string,std::string >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< std::string,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1string_1pair_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {
  jlong jresult = 0 ;
  std::string arg1 ;
  std::string arg2 ;
  std::pair< std::string,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (std::pair< std::string,std::string > *)new std::pair< std::string,std::string >(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< std::string,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1string_1pair_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< std::string,std::string > *arg1 = 0 ;
  std::pair< std::string,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::string,std::string > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< std::string,std::string > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< std::string,std::string > *)new std::pair< std::string,std::string >((std::pair< std::string,std::string > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< std::string,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1first_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  std::pair< std::string,std::string > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::string,std::string > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->first = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1first_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::pair< std::string,std::string > *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::string,std::string > **)&jarg1; 
  result = (std::string *) & ((arg1)->first);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1second_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  std::pair< std::string,std::string > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::string,std::string > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->second = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1second_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::pair< std::string,std::string > *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::string,std::string > **)&jarg1; 
  result = (std::string *) & ((arg1)->second);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1string_1pair(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::pair< std::string,std::string > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< std::string,std::string > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1vector_1byte_1vector_1pair_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *)new std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1vector_1byte_1vector_1pair_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::vector< std::int8_t > arg1 ;
  std::vector< std::int8_t > arg2 ;
  std::vector< std::int8_t > *argp1 ;
  std::vector< std::int8_t > *argp2 ;
  std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  argp1 = *(std::vector< std::int8_t > **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::int8_t >");
    return 0;
  }
  arg1 = *argp1; 
  argp2 = *(std::vector< std::int8_t > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::int8_t >");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *)new std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > >(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1vector_1byte_1vector_1pair_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *arg1 = 0 ;
  std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *)new std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > >((std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1byte_1vector_1pair_1first_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2; 
  if (arg1) (arg1)->first = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1byte_1vector_1pair_1first_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *arg1 = 0 ;
  std::vector< std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > **)&jarg1; 
  result = (std::vector< std::int8_t > *)& ((arg1)->first);
  *(std::vector< std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1byte_1vector_1pair_1second_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2; 
  if (arg1) (arg1)->second = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1byte_1vector_1pair_1second_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *arg1 = 0 ;
  std::vector< std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > **)&jarg1; 
  result = (std::vector< std::int8_t > *)& ((arg1)->second);
  *(std::vector< std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1byte_1vector_1byte_1vector_1pair(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< std::vector< std::int8_t >,std::vector< std::int8_t > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1udp_1endpoint_1pair_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *)new std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1udp_1endpoint_1pair_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::digest32< 160 > arg1 ;
  libtorrent::udp::endpoint arg2 ;
  libtorrent::digest32< 160 > *argp1 ;
  libtorrent::udp::endpoint *argp2 ;
  std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  argp1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::digest32< 160 >");
    return 0;
  }
  arg1 = *argp1; 
  argp2 = *(libtorrent::udp::endpoint **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::udp::endpoint");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *)new std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint >(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1udp_1endpoint_1pair_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *arg1 = 0 ;
  std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *)new std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint >((std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1first_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *arg1 = 0 ;
  libtorrent::digest32< 160 > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 160 > **)&jarg2; 
  if (arg1) (arg1)->first = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1first_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *arg1 = 0 ;
  libtorrent::digest32< 160 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > **)&jarg1; 
  result = (libtorrent::digest32< 160 > *)& ((arg1)->first);
  *(libtorrent::digest32< 160 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1second_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *arg1 = 0 ;
  libtorrent::udp::endpoint *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = *(libtorrent::udp::endpoint **)&jarg2; 
  if (arg1) (arg1)->second = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1second_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *arg1 = 0 ;
  libtorrent::udp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > **)&jarg1; 
  result = (libtorrent::udp::endpoint *)& ((arg1)->second);
  *(libtorrent::udp::endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1sha1_1hash_1udp_1endpoint_1pair(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bdecode_1node_1bdecode_1node_1pair_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *)new std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bdecode_1node_1bdecode_1node_1pair_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node arg1 ;
  libtorrent::bdecode_node arg2 ;
  libtorrent::bdecode_node *argp1 ;
  libtorrent::bdecode_node *argp2 ;
  std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  argp1 = *(libtorrent::bdecode_node **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::bdecode_node");
    return 0;
  }
  arg1 = *argp1; 
  argp2 = *(libtorrent::bdecode_node **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::bdecode_node");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *)new std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node >(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bdecode_1node_1bdecode_1node_1pair_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *arg1 = 0 ;
  std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *)new std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node >((std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1bdecode_1node_1pair_1first_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *arg1 = 0 ;
  libtorrent::bdecode_node *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > **)&jarg1; 
  arg2 = *(libtorrent::bdecode_node **)&jarg2; 
  if (arg1) (arg1)->first = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1bdecode_1node_1pair_1first_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *arg1 = 0 ;
  libtorrent::bdecode_node *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > **)&jarg1; 
  result = (libtorrent::bdecode_node *)& ((arg1)->first);
  *(libtorrent::bdecode_node **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1bdecode_1node_1pair_1second_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *arg1 = 0 ;
  libtorrent::bdecode_node *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > **)&jarg1; 
  arg2 = *(libtorrent::bdecode_node **)&jarg2; 
  if (arg1) (arg1)->second = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1bdecode_1node_1pair_1second_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *arg1 = 0 ;
  libtorrent::bdecode_node *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > **)&jarg1; 
  result = (libtorrent::bdecode_node *)& ((arg1)->second);
  *(libtorrent::bdecode_node **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bdecode_1node_1bdecode_1node_1pair(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1address_1sha1_1hash_1pair_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::pair< libtorrent::address,libtorrent::digest32< 160 > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< libtorrent::address,libtorrent::digest32< 160 > > *)new std::pair< libtorrent::address,libtorrent::digest32< 160 > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::address,libtorrent::digest32< 160 > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1address_1sha1_1hash_1pair_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::address arg1 ;
  libtorrent::digest32< 160 > arg2 ;
  libtorrent::address *argp1 ;
  libtorrent::digest32< 160 > *argp2 ;
  std::pair< libtorrent::address,libtorrent::digest32< 160 > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  argp1 = *(libtorrent::address **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::address");
    return 0;
  }
  arg1 = *argp1; 
  argp2 = *(libtorrent::digest32< 160 > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::digest32< 160 >");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (std::pair< libtorrent::address,libtorrent::digest32< 160 > > *)new std::pair< libtorrent::address,libtorrent::digest32< 160 > >(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::address,libtorrent::digest32< 160 > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1address_1sha1_1hash_1pair_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::address,libtorrent::digest32< 160 > > *arg1 = 0 ;
  std::pair< libtorrent::address,libtorrent::digest32< 160 > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::address,libtorrent::digest32< 160 > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< libtorrent::address,libtorrent::digest32< 160 > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< libtorrent::address,libtorrent::digest32< 160 > > *)new std::pair< libtorrent::address,libtorrent::digest32< 160 > >((std::pair< libtorrent::address,libtorrent::digest32< 160 > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::address,libtorrent::digest32< 160 > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1first_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::pair< libtorrent::address,libtorrent::digest32< 160 > > *arg1 = 0 ;
  libtorrent::address *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::address,libtorrent::digest32< 160 > > **)&jarg1; 
  arg2 = *(libtorrent::address **)&jarg2; 
  if (arg1) (arg1)->first = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1first_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::address,libtorrent::digest32< 160 > > *arg1 = 0 ;
  libtorrent::address *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::address,libtorrent::digest32< 160 > > **)&jarg1; 
  result = (libtorrent::address *)& ((arg1)->first);
  *(libtorrent::address **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1second_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::pair< libtorrent::address,libtorrent::digest32< 160 > > *arg1 = 0 ;
  libtorrent::digest32< 160 > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::address,libtorrent::digest32< 160 > > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 160 > **)&jarg2; 
  if (arg1) (arg1)->second = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1second_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::address,libtorrent::digest32< 160 > > *arg1 = 0 ;
  libtorrent::digest32< 160 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::address,libtorrent::digest32< 160 > > **)&jarg1; 
  result = (libtorrent::digest32< 160 > *)& ((arg1)->second);
  *(libtorrent::digest32< 160 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1address_1sha1_1hash_1pair(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::pair< libtorrent::address,libtorrent::digest32< 160 > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< libtorrent::address,libtorrent::digest32< 160 > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::string > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::string > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::string > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jstring jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::string *arg2 = 0 ;
  std::vector< std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      try {
        result = (std::vector< std::string > *)new_std_vector_Sl_std_string_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::string const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::string > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_string_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::string > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_string_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::string > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_string_Sg__doSize((std::vector< std::string > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  std::vector< std::string > *arg1 = 0 ;
  std::vector< std::string >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::vector< std::string >::value_type arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      std_vector_Sl_std_string_Sg__doAdd__SWIG_0(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
  std::vector< std::string > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  arg2 = jarg2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::vector< std::string >::value_type arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      try {
        std_vector_Sl_std_string_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jstring jresult = 0 ;
  std::vector< std::string > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::string >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_string_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jstring jresult = 0 ;
  std::vector< std::string > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
  jstring jresult = 0 ;
  std::vector< std::string > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  std::vector< std::string >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  arg2 = jarg2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return 0;
  std::vector< std::string >::value_type arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      try {
        result = std_vector_Sl_std_string_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::string > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_string_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::string > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< int > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< int > *)new std::vector< int >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< int > *arg1 = 0 ;
  std::vector< int > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< int > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< int > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< int > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  int *arg2 = 0 ;
  int temp2 ;
  std::vector< int > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      try {
        result = (std::vector< int > *)new_std_vector_Sl_int_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(int const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< int > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_int_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< int > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_int_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< int > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_int_Sg__doSize((std::vector< int > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< int > *arg1 = 0 ;
  std::vector< int >::value_type *arg2 = 0 ;
  std::vector< int >::value_type temp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  temp2 = (std::vector< int >::value_type)jarg2; 
  arg2 = &temp2; 
  {
    try {
      std_vector_Sl_int_Sg__doAdd__SWIG_0(arg1,(int const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< int > *arg1 = 0 ;
  jint arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  std::vector< int >::value_type temp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = (std::vector< int >::value_type)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_int_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(int const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jint jresult = 0 ;
  std::vector< int > *arg1 = 0 ;
  jint arg2 ;
  std::vector< int >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jint jresult = 0 ;
  std::vector< int > *arg1 = 0 ;
  jint arg2 ;
  std::vector< int >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< int >::value_type *) &std_vector_Sl_int_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)*result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  jint jresult = 0 ;
  std::vector< int > *arg1 = 0 ;
  jint arg2 ;
  std::vector< int >::value_type *arg3 = 0 ;
  std::vector< int >::value_type temp3 ;
  std::vector< int >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = (std::vector< int >::value_type)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        result = (std::vector< int >::value_type)std_vector_Sl_int_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(int const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< int > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_int_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1int_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< int > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< int > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int64_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< long long > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< long long > *)new std::vector< long long >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< long long > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int64_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< long long > *arg1 = 0 ;
  std::vector< long long > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< long long > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< long long > *)new std::vector< long long >((std::vector< long long > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< long long > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< long long > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< long long > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< long long > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int64_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  long long *arg2 = 0 ;
  long long temp2 ;
  std::vector< long long > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  temp2 = (long long)jarg2; 
  arg2 = &temp2; 
  {
    try {
      try {
        result = (std::vector< long long > *)new_std_vector_Sl_long_SS_long_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(long long const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< long long > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< long long > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_long_SS_long_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< long long > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_long_SS_long_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< long long > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_long_SS_long_Sg__doSize((std::vector< long long > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< long long > *arg1 = 0 ;
  std::vector< long long >::value_type *arg2 = 0 ;
  std::vector< long long >::value_type temp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  temp2 = (std::vector< long long >::value_type)jarg2; 
  arg2 = &temp2; 
  {
    try {
      std_vector_Sl_long_SS_long_Sg__doAdd__SWIG_0(arg1,(long long const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  std::vector< long long > *arg1 = 0 ;
  jint arg2 ;
  std::vector< long long >::value_type *arg3 = 0 ;
  std::vector< long long >::value_type temp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = (std::vector< long long >::value_type)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_long_SS_long_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(long long const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< long long > *arg1 = 0 ;
  jint arg2 ;
  std::vector< long long >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< long long >::value_type)std_vector_Sl_long_SS_long_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< long long > *arg1 = 0 ;
  jint arg2 ;
  std::vector< long long >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< long long >::value_type *) &std_vector_Sl_long_SS_long_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)*result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  std::vector< long long > *arg1 = 0 ;
  jint arg2 ;
  std::vector< long long >::value_type *arg3 = 0 ;
  std::vector< long long >::value_type temp3 ;
  std::vector< long long >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = (std::vector< long long >::value_type)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        result = (std::vector< long long >::value_type)std_vector_Sl_long_SS_long_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(long long const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< long long > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_long_SS_long_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1int64_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< long long > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< long long > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::int8_t > *)new std::vector< std::int8_t >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  std::vector< std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< std::int8_t > *)new std::vector< std::int8_t >((std::vector< std::int8_t > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::int8_t > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::int8_t > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jbyte jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::int8_t *arg2 = 0 ;
  std::int8_t temp2 ;
  std::vector< std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  temp2 = (std::int8_t)jarg2; 
  arg2 = &temp2; 
  {
    try {
      try {
        result = (std::vector< std::int8_t > *)new_std_vector_Sl_std_int8_t_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(signed char const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_int8_t_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::int8_t > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_int8_t_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_int8_t_Sg__doSize((std::vector< signed char > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jbyte jarg2) {
  std::vector< std::int8_t > *arg1 = 0 ;
  std::vector< signed char >::value_type *arg2 = 0 ;
  std::vector< signed char >::value_type temp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  temp2 = (std::vector< signed char >::value_type)jarg2; 
  arg2 = &temp2; 
  {
    try {
      std_vector_Sl_std_int8_t_Sg__doAdd__SWIG_0(arg1,(signed char const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jbyte jarg3) {
  std::vector< std::int8_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< signed char >::value_type *arg3 = 0 ;
  std::vector< signed char >::value_type temp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = (std::vector< signed char >::value_type)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_std_int8_t_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(signed char const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jbyte jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< signed char >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< signed char >::value_type)std_vector_Sl_std_int8_t_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jbyte jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< signed char >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< signed char >::value_type *) &std_vector_Sl_std_int8_t_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)*result; 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jbyte jarg3) {
  jbyte jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< signed char >::value_type *arg3 = 0 ;
  std::vector< signed char >::value_type temp3 ;
  std::vector< signed char >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = (std::vector< signed char >::value_type)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        result = (std::vector< signed char >::value_type)std_vector_Sl_std_int8_t_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(signed char const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::int8_t > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_int8_t_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1byte_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::int8_t > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::int8_t > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bool_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< bool > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< bool > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bool_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< bool > *arg1 = 0 ;
  std::vector< bool > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< bool > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< bool > *)new std::vector< bool >((std::vector< bool > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< bool > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< bool > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< bool > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< bool > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bool_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jboolean jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  bool *arg2 = 0 ;
  bool temp2 ;
  std::vector< bool > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  temp2 = jarg2 ? true : false; 
  arg2 = &temp2; 
  {
    try {
      try {
        result = (std::vector< bool > *)new_std_vector_Sl_bool_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(bool const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< bool > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< bool > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_bool_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< bool > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_bool_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< bool > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_bool_Sg__doSize((std::vector< bool > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  std::vector< bool > *arg1 = 0 ;
  std::vector< bool >::value_type *arg2 = 0 ;
  std::vector< bool >::value_type temp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1; 
  temp2 = jarg2 ? true : false; 
  arg2 = &temp2; 
  {
    try {
      std_vector_Sl_bool_Sg__doAdd__SWIG_0(arg1,(bool const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
  std::vector< bool > *arg1 = 0 ;
  jint arg2 ;
  std::vector< bool >::value_type *arg3 = 0 ;
  std::vector< bool >::value_type temp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = jarg3 ? true : false; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_bool_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(bool const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jboolean jresult = 0 ;
  std::vector< bool > *arg1 = 0 ;
  jint arg2 ;
  std::vector< bool >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< bool >::value_type)std_vector_Sl_bool_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jboolean jresult = 0 ;
  std::vector< bool > *arg1 = 0 ;
  jint arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (bool)std_vector_Sl_bool_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
  jboolean jresult = 0 ;
  std::vector< bool > *arg1 = 0 ;
  jint arg2 ;
  std::vector< bool >::value_type *arg3 = 0 ;
  std::vector< bool >::value_type temp3 ;
  std::vector< bool >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = jarg3 ? true : false; 
  arg3 = &temp3; 
  {
    try {
      try {
        result = (std::vector< bool >::value_type)std_vector_Sl_bool_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(bool const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< bool > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< bool > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_bool_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bool_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< bool > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< bool > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1byte_1pair_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::pair< int,std::int8_t > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::pair< int,std::int8_t > > *)new std::vector< std::pair< int,std::int8_t > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< int,std::int8_t > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1byte_1pair_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  std::vector< std::pair< int,std::int8_t > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< int,std::int8_t > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< std::pair< int,std::int8_t > > *)new std::vector< std::pair< int,std::int8_t > >((std::vector< std::pair< int,std::int8_t > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< int,std::int8_t > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::pair< int,std::int8_t > > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1byte_1pair_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::pair< int,std::int8_t > *arg2 = 0 ;
  std::vector< std::pair< int,std::int8_t > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(std::pair< int,std::int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< int,std::int8_t > const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< std::pair< int,std::int8_t > > *)new_std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::pair< int,signed char > const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< int,std::int8_t > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doSize((std::vector< std::pair< int,signed char > > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  std::vector< std::pair< int,signed char > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  arg2 = *(std::vector< std::pair< int,signed char > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< int,signed char > >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doAdd__SWIG_0(arg1,(std::pair< int,signed char > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< int,signed char > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< int,signed char > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< int,signed char > >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::pair< int,signed char > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< int,signed char > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< int,signed char > >::value_type **)&jresult = new std::vector< std::pair< int,signed char > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< int,signed char > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< int,signed char > >::value_type *) &std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< int,signed char > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< int,signed char > >::value_type *arg3 = 0 ;
  std::vector< std::pair< int,signed char > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< int,signed char > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< int,signed char > >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::pair< int,signed char > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< int,signed char > >::value_type **)&jresult = new std::vector< std::pair< int,signed char > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1byte_1pair_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_int_Sc_std_int8_t_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1int_1byte_1pair_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::pair< int,std::int8_t > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::pair< int,std::int8_t > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1int_1pair_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,int > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::pair< std::string,int > > *)new std::vector< std::pair< std::string,int > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,int > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1int_1pair_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  std::vector< std::pair< std::string,int > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< std::string,int > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< std::pair< std::string,int > > *)new std::vector< std::pair< std::string,int > >((std::vector< std::pair< std::string,int > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,int > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::pair< std::string,int > > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1int_1pair_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::pair< std::string,int > *arg2 = 0 ;
  std::vector< std::pair< std::string,int > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(std::pair< std::string,int > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< std::string,int > const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< std::pair< std::string,int > > *)new_std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::pair< std::string,int > const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,int > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doSize((std::vector< std::pair< std::string,int > > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  std::vector< std::pair< std::string,int > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  arg2 = *(std::vector< std::pair< std::string,int > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< std::string,int > >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doAdd__SWIG_0(arg1,(std::pair< std::string,int > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< std::string,int > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< std::string,int > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< std::string,int > >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::pair< std::string,int > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< std::string,int > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,int > >::value_type **)&jresult = new std::vector< std::pair< std::string,int > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< std::string,int > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< std::string,int > >::value_type *) &std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,int > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< std::string,int > >::value_type *arg3 = 0 ;
  std::vector< std::pair< std::string,int > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< std::string,int > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< std::string,int > >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::pair< std::string,int > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,int > >::value_type **)&jresult = new std::vector< std::pair< std::string,int > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1int_1pair_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::pair< std::string,int > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1string_1pair_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::pair< std::string,std::string > > *)new std::vector< std::pair< std::string,std::string > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,std::string > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1string_1pair_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  std::vector< std::pair< std::string,std::string > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< std::string,std::string > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< std::pair< std::string,std::string > > *)new std::vector< std::pair< std::string,std::string > >((std::vector< std::pair< std::string,std::string > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,std::string > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::pair< std::string,std::string > > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1string_1pair_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::pair< std::string,std::string > *arg2 = 0 ;
  std::vector< std::pair< std::string,std::string > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(std::pair< std::string,std::string > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< std::string,std::string > const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< std::pair< std::string,std::string > > *)new_std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::pair< std::string,std::string > const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,std::string > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doSize((std::vector< std::pair< std::string,std::string > > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  std::vector< std::pair< std::string,std::string > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  arg2 = *(std::vector< std::pair< std::string,std::string > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< std::string,std::string > >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doAdd__SWIG_0(arg1,(std::pair< std::string,std::string > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< std::string,std::string > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< std::string,std::string > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< std::string,std::string > >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::pair< std::string,std::string > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< std::string,std::string > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,std::string > >::value_type **)&jresult = new std::vector< std::pair< std::string,std::string > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< std::string,std::string > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< std::string,std::string > >::value_type *) &std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,std::string > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< std::string,std::string > >::value_type *arg3 = 0 ;
  std::vector< std::pair< std::string,std::string > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< std::string,std::string > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< std::string,std::string > >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::pair< std::string,std::string > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,std::string > >::value_type **)&jresult = new std::vector< std::pair< std::string,std::string > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1string_1pair_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::pair< std::string,std::string > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1tcp_1endpoint_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::tcp::endpoint > *)new std::vector< libtorrent::tcp::endpoint >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::tcp::endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1tcp_1endpoint_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  std::vector< libtorrent::tcp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::tcp::endpoint > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::tcp::endpoint > *)new std::vector< libtorrent::tcp::endpoint >((std::vector< libtorrent::tcp::endpoint > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::tcp::endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::tcp::endpoint > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1tcp_1endpoint_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::tcp::endpoint *arg2 = 0 ;
  std::vector< libtorrent::tcp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::tcp::endpoint **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::tcp::endpoint const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::tcp::endpoint > *)new_std_vector_Sl_libtorrent_tcp_endpoint_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::tcp::endpoint const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::tcp::endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_tcp_endpoint_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_tcp_endpoint_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_tcp_endpoint_Sg__doSize((std::vector< libtorrent::tcp::endpoint > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  std::vector< libtorrent::tcp::endpoint >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::tcp::endpoint >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::tcp::endpoint >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_tcp_endpoint_Sg__doAdd__SWIG_0(arg1,(libtorrent::tcp::endpoint const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::tcp::endpoint >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::tcp::endpoint >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::tcp::endpoint >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_tcp_endpoint_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::tcp::endpoint const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::tcp::endpoint >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_tcp_endpoint_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::tcp::endpoint >::value_type **)&jresult = new std::vector< libtorrent::tcp::endpoint >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::tcp::endpoint >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::tcp::endpoint >::value_type *) &std_vector_Sl_libtorrent_tcp_endpoint_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::tcp::endpoint >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::tcp::endpoint >::value_type *arg3 = 0 ;
  std::vector< libtorrent::tcp::endpoint >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::tcp::endpoint >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::tcp::endpoint >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_tcp_endpoint_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::tcp::endpoint const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::tcp::endpoint >::value_type **)&jresult = new std::vector< libtorrent::tcp::endpoint >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_tcp_endpoint_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1tcp_1endpoint_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::tcp::endpoint > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1udp_1endpoint_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::udp::endpoint > *)new std::vector< libtorrent::udp::endpoint >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::udp::endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1udp_1endpoint_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  std::vector< libtorrent::udp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::udp::endpoint > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::udp::endpoint > *)new std::vector< libtorrent::udp::endpoint >((std::vector< libtorrent::udp::endpoint > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::udp::endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::udp::endpoint > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1udp_1endpoint_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::udp::endpoint *arg2 = 0 ;
  std::vector< libtorrent::udp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::udp::endpoint **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::udp::endpoint const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::udp::endpoint > *)new_std_vector_Sl_libtorrent_udp_endpoint_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::udp::endpoint const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::udp::endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_udp_endpoint_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_udp_endpoint_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_udp_endpoint_Sg__doSize((std::vector< libtorrent::udp::endpoint > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  std::vector< libtorrent::udp::endpoint >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::udp::endpoint >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::udp::endpoint >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_udp_endpoint_Sg__doAdd__SWIG_0(arg1,(libtorrent::udp::endpoint const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::udp::endpoint >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::udp::endpoint >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::udp::endpoint >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_udp_endpoint_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::udp::endpoint const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::udp::endpoint >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_udp_endpoint_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::udp::endpoint >::value_type **)&jresult = new std::vector< libtorrent::udp::endpoint >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::udp::endpoint >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::udp::endpoint >::value_type *) &std_vector_Sl_libtorrent_udp_endpoint_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::udp::endpoint >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::udp::endpoint >::value_type *arg3 = 0 ;
  std::vector< libtorrent::udp::endpoint >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::udp::endpoint >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::udp::endpoint >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_udp_endpoint_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::udp::endpoint const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::udp::endpoint >::value_type **)&jresult = new std::vector< libtorrent::udp::endpoint >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_udp_endpoint_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1udp_1endpoint_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::udp::endpoint > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1announce_1endpoint_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::announce_endpoint > *)new std::vector< libtorrent::announce_endpoint >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1announce_1endpoint_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  std::vector< libtorrent::announce_endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::announce_endpoint > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::announce_endpoint > *)new std::vector< libtorrent::announce_endpoint >((std::vector< libtorrent::announce_endpoint > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::announce_endpoint > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1announce_1endpoint_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::announce_endpoint *arg2 = 0 ;
  std::vector< libtorrent::announce_endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::announce_endpoint **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::announce_endpoint const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::announce_endpoint > *)new_std_vector_Sl_libtorrent_announce_endpoint_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::announce_endpoint const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_announce_endpoint_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_announce_endpoint_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_announce_endpoint_Sg__doSize((std::vector< libtorrent::announce_endpoint > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  std::vector< libtorrent::announce_endpoint >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::announce_endpoint >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::announce_endpoint >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_announce_endpoint_Sg__doAdd__SWIG_0(arg1,(libtorrent::announce_endpoint const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::announce_endpoint >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::announce_endpoint >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::announce_endpoint >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_announce_endpoint_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::announce_endpoint const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::announce_endpoint >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_announce_endpoint_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_endpoint >::value_type **)&jresult = new std::vector< libtorrent::announce_endpoint >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::announce_endpoint >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::announce_endpoint >::value_type *) &std_vector_Sl_libtorrent_announce_endpoint_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_endpoint >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::announce_endpoint >::value_type *arg3 = 0 ;
  std::vector< libtorrent::announce_endpoint >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::announce_endpoint >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::announce_endpoint >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_announce_endpoint_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::announce_endpoint const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_endpoint >::value_type **)&jresult = new std::vector< libtorrent::announce_endpoint >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_announce_endpoint_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1announce_1endpoint_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::announce_endpoint > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1announce_1entry_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::announce_entry > *)new std::vector< libtorrent::announce_entry >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1announce_1entry_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  std::vector< libtorrent::announce_entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::announce_entry > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::announce_entry > *)new std::vector< libtorrent::announce_entry >((std::vector< libtorrent::announce_entry > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::announce_entry > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1announce_1entry_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::announce_entry *arg2 = 0 ;
  std::vector< libtorrent::announce_entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::announce_entry **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::announce_entry const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::announce_entry > *)new_std_vector_Sl_libtorrent_announce_entry_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::announce_entry const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_announce_entry_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_announce_entry_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_announce_entry_Sg__doSize((std::vector< libtorrent::announce_entry > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  std::vector< libtorrent::announce_entry >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::announce_entry >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::announce_entry >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_announce_entry_Sg__doAdd__SWIG_0(arg1,(libtorrent::announce_entry const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::announce_entry >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::announce_entry >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::announce_entry >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_announce_entry_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::announce_entry const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::announce_entry >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_announce_entry_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_entry >::value_type **)&jresult = new std::vector< libtorrent::announce_entry >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::announce_entry >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::announce_entry >::value_type *) &std_vector_Sl_libtorrent_announce_entry_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_entry >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::announce_entry >::value_type *arg3 = 0 ;
  std::vector< libtorrent::announce_entry >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::announce_entry >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::announce_entry >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_announce_entry_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::announce_entry const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_entry >::value_type **)&jresult = new std::vector< libtorrent::announce_entry >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_announce_entry_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1announce_1entry_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::announce_entry > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1web_1seed_1entry_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::web_seed_entry > *)new std::vector< libtorrent::web_seed_entry >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::web_seed_entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1web_1seed_1entry_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  std::vector< libtorrent::web_seed_entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::web_seed_entry > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::web_seed_entry > *)new std::vector< libtorrent::web_seed_entry >((std::vector< libtorrent::web_seed_entry > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::web_seed_entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::web_seed_entry > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1web_1seed_1entry_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::web_seed_entry *arg2 = 0 ;
  std::vector< libtorrent::web_seed_entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::web_seed_entry **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::web_seed_entry const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::web_seed_entry > *)new_std_vector_Sl_libtorrent_web_seed_entry_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::web_seed_entry const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::web_seed_entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_web_seed_entry_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_web_seed_entry_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_web_seed_entry_Sg__doSize((std::vector< libtorrent::web_seed_entry > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  std::vector< libtorrent::web_seed_entry >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::web_seed_entry >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::web_seed_entry >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_web_seed_entry_Sg__doAdd__SWIG_0(arg1,(libtorrent::web_seed_entry const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::web_seed_entry >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::web_seed_entry >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::web_seed_entry >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_web_seed_entry_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::web_seed_entry const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  jint arg2 ;
  SwigValueWrapper< libtorrent::web_seed_entry > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_web_seed_entry_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::web_seed_entry >::value_type **)&jresult = new std::vector< libtorrent::web_seed_entry >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::web_seed_entry >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::web_seed_entry >::value_type *) &std_vector_Sl_libtorrent_web_seed_entry_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::web_seed_entry >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::web_seed_entry >::value_type *arg3 = 0 ;
  SwigValueWrapper< libtorrent::web_seed_entry > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::web_seed_entry >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::web_seed_entry >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_web_seed_entry_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::web_seed_entry const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::web_seed_entry >::value_type **)&jresult = new std::vector< libtorrent::web_seed_entry >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_web_seed_entry_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1web_1seed_1entry_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::web_seed_entry > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1slice_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_slice > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::file_slice > *)new std::vector< libtorrent::file_slice >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_slice > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1slice_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  std::vector< libtorrent::file_slice > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::file_slice > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::file_slice > *)new std::vector< libtorrent::file_slice >((std::vector< libtorrent::file_slice > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_slice > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::file_slice > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1slice_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::file_slice *arg2 = 0 ;
  std::vector< libtorrent::file_slice > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::file_slice **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_slice const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::file_slice > *)new_std_vector_Sl_libtorrent_file_slice_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::file_slice const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_slice > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_file_slice_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_file_slice_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_file_slice_Sg__doSize((std::vector< libtorrent::file_slice > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  std::vector< libtorrent::file_slice >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::file_slice >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::file_slice >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_file_slice_Sg__doAdd__SWIG_0(arg1,(libtorrent::file_slice const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::file_slice >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::file_slice >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::file_slice >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_file_slice_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::file_slice const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::file_slice >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_file_slice_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_slice >::value_type **)&jresult = new std::vector< libtorrent::file_slice >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::file_slice >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::file_slice >::value_type *) &std_vector_Sl_libtorrent_file_slice_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_slice >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::file_slice >::value_type *arg3 = 0 ;
  std::vector< libtorrent::file_slice >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::file_slice >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::file_slice >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_file_slice_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::file_slice const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_slice >::value_type **)&jresult = new std::vector< libtorrent::file_slice >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_file_slice_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1slice_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::file_slice > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1block_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::piece_block > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::piece_block > *)new std::vector< libtorrent::piece_block >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_block > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1block_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  std::vector< libtorrent::piece_block > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::piece_block > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::piece_block > *)new std::vector< libtorrent::piece_block >((std::vector< libtorrent::piece_block > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_block > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::piece_block > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1block_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::piece_block *arg2 = 0 ;
  std::vector< libtorrent::piece_block > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::piece_block **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::piece_block const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::piece_block > *)new_std_vector_Sl_libtorrent_piece_block_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::piece_block const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_block > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_piece_block_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_piece_block_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_piece_block_Sg__doSize((std::vector< libtorrent::piece_block > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  std::vector< libtorrent::piece_block >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::piece_block >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::piece_block >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_piece_block_Sg__doAdd__SWIG_0(arg1,(libtorrent::piece_block const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::piece_block >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::piece_block >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::piece_block >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_piece_block_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::piece_block const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::piece_block >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_piece_block_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_block >::value_type **)&jresult = new std::vector< libtorrent::piece_block >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::piece_block >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::piece_block >::value_type *) &std_vector_Sl_libtorrent_piece_block_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_block >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::piece_block >::value_type *arg3 = 0 ;
  std::vector< libtorrent::piece_block >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::piece_block >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::piece_block >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_piece_block_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::piece_block const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_block >::value_type **)&jresult = new std::vector< libtorrent::piece_block >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_piece_block_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1piece_1block_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::piece_block > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::piece_block > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1status_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_status > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::torrent_status > *)new std::vector< libtorrent::torrent_status >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_status > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1status_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  std::vector< libtorrent::torrent_status > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::torrent_status > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::torrent_status > *)new std::vector< libtorrent::torrent_status >((std::vector< libtorrent::torrent_status > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_status > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::torrent_status > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1status_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::torrent_status *arg2 = 0 ;
  std::vector< libtorrent::torrent_status > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::torrent_status **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_status const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::torrent_status > *)new_std_vector_Sl_libtorrent_torrent_status_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::torrent_status const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_status > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_torrent_status_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_torrent_status_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_torrent_status_Sg__doSize((std::vector< libtorrent::torrent_status > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  std::vector< libtorrent::torrent_status >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::torrent_status >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::torrent_status >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_torrent_status_Sg__doAdd__SWIG_0(arg1,(libtorrent::torrent_status const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::torrent_status >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::torrent_status >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::torrent_status >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_torrent_status_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::torrent_status const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::torrent_status >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_torrent_status_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_status >::value_type **)&jresult = new std::vector< libtorrent::torrent_status >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::torrent_status >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::torrent_status >::value_type *) &std_vector_Sl_libtorrent_torrent_status_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_status >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::torrent_status >::value_type *arg3 = 0 ;
  std::vector< libtorrent::torrent_status >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::torrent_status >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::torrent_status >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_torrent_status_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::torrent_status const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_status >::value_type **)&jresult = new std::vector< libtorrent::torrent_status >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_torrent_status_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1status_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::torrent_status > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1dht_1lookup_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::dht_lookup > *)new std::vector< libtorrent::dht_lookup >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_lookup > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1dht_1lookup_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  std::vector< libtorrent::dht_lookup > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::dht_lookup > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::dht_lookup > *)new std::vector< libtorrent::dht_lookup >((std::vector< libtorrent::dht_lookup > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_lookup > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::dht_lookup > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1dht_1lookup_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::dht_lookup *arg2 = 0 ;
  std::vector< libtorrent::dht_lookup > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::dht_lookup **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::dht_lookup const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::dht_lookup > *)new_std_vector_Sl_libtorrent_dht_lookup_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::dht_lookup const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_lookup > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_dht_lookup_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_dht_lookup_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_dht_lookup_Sg__doSize((std::vector< libtorrent::dht_lookup > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  std::vector< libtorrent::dht_lookup >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::dht_lookup >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::dht_lookup >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_dht_lookup_Sg__doAdd__SWIG_0(arg1,(libtorrent::dht_lookup const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::dht_lookup >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::dht_lookup >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::dht_lookup >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_dht_lookup_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::dht_lookup const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::dht_lookup >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_dht_lookup_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_lookup >::value_type **)&jresult = new std::vector< libtorrent::dht_lookup >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::dht_lookup >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::dht_lookup >::value_type *) &std_vector_Sl_libtorrent_dht_lookup_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_lookup >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::dht_lookup >::value_type *arg3 = 0 ;
  std::vector< libtorrent::dht_lookup >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::dht_lookup >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::dht_lookup >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_dht_lookup_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::dht_lookup const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_lookup >::value_type **)&jresult = new std::vector< libtorrent::dht_lookup >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_dht_lookup_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1lookup_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::dht_lookup > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1dht_1routing_1bucket_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::dht_routing_bucket > *)new std::vector< libtorrent::dht_routing_bucket >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_routing_bucket > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1dht_1routing_1bucket_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::dht_routing_bucket > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::dht_routing_bucket > *)new std::vector< libtorrent::dht_routing_bucket >((std::vector< libtorrent::dht_routing_bucket > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_routing_bucket > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::dht_routing_bucket > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1dht_1routing_1bucket_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::dht_routing_bucket *arg2 = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::dht_routing_bucket **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::dht_routing_bucket const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::dht_routing_bucket > *)new_std_vector_Sl_libtorrent_dht_routing_bucket_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::dht_routing_bucket const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_routing_bucket > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doSize((std::vector< libtorrent::dht_routing_bucket > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  std::vector< libtorrent::dht_routing_bucket >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::dht_routing_bucket >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::dht_routing_bucket >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doAdd__SWIG_0(arg1,(libtorrent::dht_routing_bucket const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::dht_routing_bucket >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::dht_routing_bucket >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::dht_routing_bucket >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::dht_routing_bucket const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::dht_routing_bucket >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_routing_bucket >::value_type **)&jresult = new std::vector< libtorrent::dht_routing_bucket >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::dht_routing_bucket >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::dht_routing_bucket >::value_type *) &std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_routing_bucket >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::dht_routing_bucket >::value_type *arg3 = 0 ;
  std::vector< libtorrent::dht_routing_bucket >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::dht_routing_bucket >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::dht_routing_bucket >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::dht_routing_bucket const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::dht_routing_bucket >::value_type **)&jresult = new std::vector< libtorrent::dht_routing_bucket >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_dht_routing_bucket_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1routing_1bucket_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::dht_routing_bucket > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1entry_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::entry > *)new std::vector< libtorrent::entry >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1entry_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::entry > *arg1 = 0 ;
  std::vector< libtorrent::entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::entry > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::entry > *)new std::vector< libtorrent::entry >((std::vector< libtorrent::entry > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::entry > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::entry > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::entry > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1entry_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::entry *arg2 = 0 ;
  std::vector< libtorrent::entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::entry **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::entry > *)new_std_vector_Sl_libtorrent_entry_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::entry const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::entry > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_entry_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::entry > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_entry_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::entry > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_entry_Sg__doSize((std::vector< libtorrent::entry > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::entry > *arg1 = 0 ;
  std::vector< libtorrent::entry >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::entry >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::entry >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_entry_Sg__doAdd__SWIG_0(arg1,(libtorrent::entry const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::entry > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::entry >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::entry >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::entry >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_entry_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::entry const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::entry > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::entry >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_entry_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::entry >::value_type **)&jresult = new std::vector< libtorrent::entry >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::entry > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::entry >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::entry >::value_type *) &std_vector_Sl_libtorrent_entry_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::entry >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::entry > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::entry >::value_type *arg3 = 0 ;
  std::vector< libtorrent::entry >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::entry >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::entry >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_entry_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::entry const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::entry >::value_type **)&jresult = new std::vector< libtorrent::entry >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::entry > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_entry_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1entry_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::entry > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1partial_1piece_1info_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::partial_piece_info > *)new std::vector< libtorrent::partial_piece_info >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::partial_piece_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1partial_1piece_1info_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  std::vector< libtorrent::partial_piece_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::partial_piece_info > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::partial_piece_info > *)new std::vector< libtorrent::partial_piece_info >((std::vector< libtorrent::partial_piece_info > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::partial_piece_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::partial_piece_info > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1partial_1piece_1info_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::partial_piece_info *arg2 = 0 ;
  std::vector< libtorrent::partial_piece_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::partial_piece_info **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::partial_piece_info const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::partial_piece_info > *)new_std_vector_Sl_libtorrent_partial_piece_info_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::partial_piece_info const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::partial_piece_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_partial_piece_info_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_partial_piece_info_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_partial_piece_info_Sg__doSize((std::vector< libtorrent::partial_piece_info > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  std::vector< libtorrent::partial_piece_info >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::partial_piece_info >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::partial_piece_info >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_partial_piece_info_Sg__doAdd__SWIG_0(arg1,(libtorrent::partial_piece_info const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::partial_piece_info >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::partial_piece_info >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::partial_piece_info >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_partial_piece_info_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::partial_piece_info const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::partial_piece_info >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_partial_piece_info_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::partial_piece_info >::value_type **)&jresult = new std::vector< libtorrent::partial_piece_info >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::partial_piece_info >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::partial_piece_info >::value_type *) &std_vector_Sl_libtorrent_partial_piece_info_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::partial_piece_info >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::partial_piece_info >::value_type *arg3 = 0 ;
  std::vector< libtorrent::partial_piece_info >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::partial_piece_info >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::partial_piece_info >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_partial_piece_info_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::partial_piece_info const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::partial_piece_info >::value_type **)&jresult = new std::vector< libtorrent::partial_piece_info >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_partial_piece_info_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1partial_1piece_1info_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::partial_piece_info > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1peer_1info_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::peer_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::peer_info > *)new std::vector< libtorrent::peer_info >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::peer_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1peer_1info_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  std::vector< libtorrent::peer_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::peer_info > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::peer_info > *)new std::vector< libtorrent::peer_info >((std::vector< libtorrent::peer_info > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::peer_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::peer_info > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1peer_1info_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::peer_info *arg2 = 0 ;
  std::vector< libtorrent::peer_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::peer_info **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::peer_info const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::peer_info > *)new_std_vector_Sl_libtorrent_peer_info_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::peer_info const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::peer_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_peer_info_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_peer_info_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_peer_info_Sg__doSize((std::vector< libtorrent::peer_info > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  std::vector< libtorrent::peer_info >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::peer_info >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::peer_info >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_peer_info_Sg__doAdd__SWIG_0(arg1,(libtorrent::peer_info const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::peer_info >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::peer_info >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::peer_info >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_peer_info_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::peer_info const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::peer_info >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_peer_info_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::peer_info >::value_type **)&jresult = new std::vector< libtorrent::peer_info >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::peer_info >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::peer_info >::value_type *) &std_vector_Sl_libtorrent_peer_info_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::peer_info >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::peer_info >::value_type *arg3 = 0 ;
  std::vector< libtorrent::peer_info >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::peer_info >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::peer_info >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_peer_info_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::peer_info const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::peer_info >::value_type **)&jresult = new std::vector< libtorrent::peer_info >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_peer_info_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1info_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::peer_info > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1handle_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::torrent_handle > *)new std::vector< libtorrent::torrent_handle >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_handle > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1handle_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  std::vector< libtorrent::torrent_handle > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::torrent_handle > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::torrent_handle > *)new std::vector< libtorrent::torrent_handle >((std::vector< libtorrent::torrent_handle > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_handle > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::torrent_handle > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1handle_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::torrent_handle *arg2 = 0 ;
  std::vector< libtorrent::torrent_handle > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::torrent_handle **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_handle const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::torrent_handle > *)new_std_vector_Sl_libtorrent_torrent_handle_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::torrent_handle const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_handle > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_torrent_handle_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_torrent_handle_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_torrent_handle_Sg__doSize((std::vector< libtorrent::torrent_handle > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  std::vector< libtorrent::torrent_handle >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::torrent_handle >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::torrent_handle >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_torrent_handle_Sg__doAdd__SWIG_0(arg1,(libtorrent::torrent_handle const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::torrent_handle >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::torrent_handle >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::torrent_handle >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_torrent_handle_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::torrent_handle const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::torrent_handle >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_torrent_handle_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_handle >::value_type **)&jresult = new std::vector< libtorrent::torrent_handle >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::torrent_handle >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::torrent_handle >::value_type *) &std_vector_Sl_libtorrent_torrent_handle_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_handle >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::torrent_handle >::value_type *arg3 = 0 ;
  std::vector< libtorrent::torrent_handle >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::torrent_handle >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::torrent_handle >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_torrent_handle_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::torrent_handle const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_handle >::value_type **)&jresult = new std::vector< libtorrent::torrent_handle >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_torrent_handle_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1handle_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::torrent_handle > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1alert_1ptr_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::alert * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::alert * > *)new std::vector< libtorrent::alert * >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::alert * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1alert_1ptr_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  std::vector< libtorrent::alert * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::alert * > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::alert * > *)new std::vector< libtorrent::alert * >((std::vector< libtorrent::alert * > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::alert * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::alert * > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1alert_1ptr_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::alert **arg2 = 0 ;
  libtorrent::alert *temp2 = 0 ;
  std::vector< libtorrent::alert * > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  temp2 = *(libtorrent::alert **)&jarg2;
  arg2 = (libtorrent::alert **)&temp2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::alert * > *)new_std_vector_Sl_libtorrent_alert_Sm__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::alert *const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::alert * > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_alert_Sm__Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_alert_Sm__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_alert_Sm__Sg__doSize((std::vector< libtorrent::alert * > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  std::vector< libtorrent::alert * >::value_type *arg2 = 0 ;
  std::vector< libtorrent::alert * >::value_type temp2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  temp2 = *(std::vector< libtorrent::alert * >::value_type *)&jarg2;
  arg2 = (std::vector< libtorrent::alert * >::value_type *)&temp2; 
  {
    try {
      std_vector_Sl_libtorrent_alert_Sm__Sg__doAdd__SWIG_0(arg1,(libtorrent::alert *const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::alert * >::value_type *arg3 = 0 ;
  std::vector< libtorrent::alert * >::value_type temp3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = *(std::vector< libtorrent::alert * >::value_type *)&jarg3;
  arg3 = (std::vector< libtorrent::alert * >::value_type *)&temp3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_alert_Sm__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::alert *const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::alert * >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::alert * >::value_type)std_vector_Sl_libtorrent_alert_Sm__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::alert * >::value_type *)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::alert * >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::alert * >::value_type *) &std_vector_Sl_libtorrent_alert_Sm__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::alert * >::value_type *)&jresult = *result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::alert * >::value_type *arg3 = 0 ;
  std::vector< libtorrent::alert * >::value_type temp3 = 0 ;
  std::vector< libtorrent::alert * >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  arg2 = jarg2; 
  temp3 = *(std::vector< libtorrent::alert * >::value_type *)&jarg3;
  arg3 = (std::vector< libtorrent::alert * >::value_type *)&temp3; 
  {
    try {
      try {
        result = (std::vector< libtorrent::alert * >::value_type)std_vector_Sl_libtorrent_alert_Sm__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::alert *const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::alert * >::value_type *)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_alert_Sm__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1alert_1ptr_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::alert * > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1stats_1metric_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::stats_metric > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::stats_metric > *)new std::vector< libtorrent::stats_metric >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::stats_metric > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1stats_1metric_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  std::vector< libtorrent::stats_metric > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::stats_metric > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::stats_metric > *)new std::vector< libtorrent::stats_metric >((std::vector< libtorrent::stats_metric > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::stats_metric > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::stats_metric > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1stats_1metric_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::stats_metric *arg2 = 0 ;
  std::vector< libtorrent::stats_metric > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::stats_metric **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::stats_metric const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::stats_metric > *)new_std_vector_Sl_libtorrent_stats_metric_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::stats_metric const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::stats_metric > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_stats_metric_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_stats_metric_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_stats_metric_Sg__doSize((std::vector< libtorrent::stats_metric > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  std::vector< libtorrent::stats_metric >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::stats_metric >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::stats_metric >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_stats_metric_Sg__doAdd__SWIG_0(arg1,(libtorrent::stats_metric const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::stats_metric >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::stats_metric >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::stats_metric >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_stats_metric_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::stats_metric const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::stats_metric >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_stats_metric_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::stats_metric >::value_type **)&jresult = new std::vector< libtorrent::stats_metric >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::stats_metric >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::stats_metric >::value_type *) &std_vector_Sl_libtorrent_stats_metric_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::stats_metric >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::stats_metric >::value_type *arg3 = 0 ;
  std::vector< libtorrent::stats_metric >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::stats_metric >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::stats_metric >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_stats_metric_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::stats_metric const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::stats_metric >::value_type **)&jresult = new std::vector< libtorrent::stats_metric >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_stats_metric_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1stats_1metric_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::stats_metric > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1ip_1interface_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< ip_interface > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< ip_interface > *)new std::vector< ip_interface >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_interface > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1ip_1interface_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< ip_interface > *arg1 = 0 ;
  std::vector< ip_interface > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_interface > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< ip_interface > *)new std::vector< ip_interface >((std::vector< ip_interface > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_interface > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< ip_interface > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< ip_interface > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< ip_interface > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1ip_1interface_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  ip_interface *arg2 = 0 ;
  std::vector< ip_interface > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(ip_interface **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "ip_interface const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< ip_interface > *)new_std_vector_Sl_ip_interface_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(ip_interface const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_interface > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< ip_interface > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_ip_interface_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< ip_interface > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_ip_interface_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< ip_interface > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_ip_interface_Sg__doSize((std::vector< ip_interface > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< ip_interface > *arg1 = 0 ;
  std::vector< ip_interface >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  arg2 = *(std::vector< ip_interface >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_interface >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_ip_interface_Sg__doAdd__SWIG_0(arg1,(ip_interface const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< ip_interface > *arg1 = 0 ;
  jint arg2 ;
  std::vector< ip_interface >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< ip_interface >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_interface >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ip_interface_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(ip_interface const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< ip_interface > *arg1 = 0 ;
  jint arg2 ;
  std::vector< ip_interface >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ip_interface_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_interface >::value_type **)&jresult = new std::vector< ip_interface >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< ip_interface > *arg1 = 0 ;
  jint arg2 ;
  std::vector< ip_interface >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< ip_interface >::value_type *) &std_vector_Sl_ip_interface_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_interface >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< ip_interface > *arg1 = 0 ;
  jint arg2 ;
  std::vector< ip_interface >::value_type *arg3 = 0 ;
  std::vector< ip_interface >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< ip_interface >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_interface >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_ip_interface_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(ip_interface const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_interface >::value_type **)&jresult = new std::vector< ip_interface >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< ip_interface > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_ip_interface_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1ip_1interface_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< ip_interface > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1ip_1route_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< ip_route > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< ip_route > *)new std::vector< ip_route >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_route > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1ip_1route_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< ip_route > *arg1 = 0 ;
  std::vector< ip_route > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_route > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< ip_route > *)new std::vector< ip_route >((std::vector< ip_route > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_route > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< ip_route > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< ip_route > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< ip_route > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1ip_1route_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  ip_route *arg2 = 0 ;
  std::vector< ip_route > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(ip_route **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "ip_route const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< ip_route > *)new_std_vector_Sl_ip_route_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(ip_route const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_route > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< ip_route > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_ip_route_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< ip_route > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_ip_route_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< ip_route > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_ip_route_Sg__doSize((std::vector< ip_route > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< ip_route > *arg1 = 0 ;
  std::vector< ip_route >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  arg2 = *(std::vector< ip_route >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_route >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_ip_route_Sg__doAdd__SWIG_0(arg1,(ip_route const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< ip_route > *arg1 = 0 ;
  jint arg2 ;
  std::vector< ip_route >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< ip_route >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_route >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ip_route_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(ip_route const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< ip_route > *arg1 = 0 ;
  jint arg2 ;
  std::vector< ip_route >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_ip_route_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_route >::value_type **)&jresult = new std::vector< ip_route >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< ip_route > *arg1 = 0 ;
  jint arg2 ;
  std::vector< ip_route >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< ip_route >::value_type *) &std_vector_Sl_ip_route_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_route >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< ip_route > *arg1 = 0 ;
  jint arg2 ;
  std::vector< ip_route >::value_type *arg3 = 0 ;
  std::vector< ip_route >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< ip_route >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_route >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_ip_route_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(ip_route const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_route >::value_type **)&jresult = new std::vector< ip_route >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< ip_route > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_ip_route_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1ip_1route_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< ip_route > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1block_1info_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::block_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::block_info > *)new std::vector< libtorrent::block_info >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::block_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1block_1info_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  std::vector< libtorrent::block_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::block_info > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::block_info > *)new std::vector< libtorrent::block_info >((std::vector< libtorrent::block_info > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::block_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::block_info > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1block_1info_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::block_info *arg2 = 0 ;
  std::vector< libtorrent::block_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::block_info **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::block_info const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::block_info > *)new_std_vector_Sl_libtorrent_block_info_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::block_info const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::block_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_block_info_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_block_info_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_block_info_Sg__doSize((std::vector< libtorrent::block_info > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  std::vector< libtorrent::block_info >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::block_info >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::block_info >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_block_info_Sg__doAdd__SWIG_0(arg1,(libtorrent::block_info const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::block_info >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::block_info >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::block_info >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_block_info_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::block_info const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::block_info >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_block_info_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::block_info >::value_type **)&jresult = new std::vector< libtorrent::block_info >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::block_info >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::block_info >::value_type *) &std_vector_Sl_libtorrent_block_info_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::block_info >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::block_info >::value_type *arg3 = 0 ;
  std::vector< libtorrent::block_info >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::block_info >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::block_info >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_block_info_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::block_info const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::block_info >::value_type **)&jresult = new std::vector< libtorrent::block_info >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_block_info_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1block_1info_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::block_info > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bitfield_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::bitfield > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::bitfield > *)new std::vector< libtorrent::bitfield >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::bitfield > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bitfield_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  std::vector< libtorrent::bitfield > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::bitfield > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::bitfield > *)new std::vector< libtorrent::bitfield >((std::vector< libtorrent::bitfield > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::bitfield > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::bitfield > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bitfield_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::bitfield *arg2 = 0 ;
  std::vector< libtorrent::bitfield > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::bitfield **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bitfield const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::bitfield > *)new_std_vector_Sl_libtorrent_bitfield_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::bitfield const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::bitfield > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_bitfield_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_bitfield_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_bitfield_Sg__doSize((std::vector< libtorrent::bitfield > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  std::vector< libtorrent::bitfield >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::bitfield >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::bitfield >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_bitfield_Sg__doAdd__SWIG_0(arg1,(libtorrent::bitfield const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::bitfield >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::bitfield >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::bitfield >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_bitfield_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::bitfield const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::bitfield >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_bitfield_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::bitfield >::value_type **)&jresult = new std::vector< libtorrent::bitfield >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::bitfield >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::bitfield >::value_type *) &std_vector_Sl_libtorrent_bitfield_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::bitfield >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::bitfield >::value_type *arg3 = 0 ;
  std::vector< libtorrent::bitfield >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::bitfield >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::bitfield >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_bitfield_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::bitfield const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::bitfield >::value_type **)&jresult = new std::vector< libtorrent::bitfield >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_bitfield_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bitfield_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::bitfield > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::bitfield > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bool_1vector_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::vector< bool > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::vector< bool > > *)new std::vector< std::vector< bool > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< bool > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bool_1vector_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::vector< bool > > *arg1 = 0 ;
  std::vector< std::vector< bool > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::vector< bool > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< std::vector< bool > > *)new std::vector< std::vector< bool > >((std::vector< std::vector< bool > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< bool > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::vector< bool > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::vector< bool > > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::vector< bool > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bool_1vector_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::vector< bool > *arg2 = 0 ;
  std::vector< std::vector< bool > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(std::vector< bool > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< bool > const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< std::vector< bool > > *)new_std_vector_Sl_std_vector_Sl_bool_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::vector< bool > const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< bool > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::vector< bool > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::vector< bool > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::vector< bool > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doSize((std::vector< std::vector< bool > > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::vector< bool > > *arg1 = 0 ;
  std::vector< std::vector< bool > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  arg2 = *(std::vector< std::vector< bool > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::vector< bool > >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doAdd__SWIG_0(arg1,(std::vector< bool > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::vector< bool > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::vector< bool > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::vector< bool > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::vector< bool > >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::vector< bool > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::vector< bool > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::vector< bool > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< bool > >::value_type **)&jresult = new std::vector< std::vector< bool > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::vector< bool > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::vector< bool > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< bool > >::value_type *) &std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< bool > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< std::vector< bool > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::vector< bool > >::value_type *arg3 = 0 ;
  std::vector< std::vector< bool > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::vector< bool > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::vector< bool > >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::vector< bool > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< bool > >::value_type **)&jresult = new std::vector< std::vector< bool > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bool_1vector_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::vector< bool > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_bool_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bool_1vector_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::vector< bool > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::vector< bool > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha256_1hash_1vector_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::vector< libtorrent::digest32< 256 > > > *)new std::vector< std::vector< libtorrent::digest32< 256 > > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha256_1hash_1vector_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::vector< libtorrent::digest32< 256 > > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< std::vector< libtorrent::digest32< 256 > > > *)new std::vector< std::vector< libtorrent::digest32< 256 > > >((std::vector< std::vector< libtorrent::digest32< 256 > > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::vector< libtorrent::digest32< 256 > > > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha256_1hash_1vector_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::vector< libtorrent::digest32< 256 > > *arg2 = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::digest32< 256 > > const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< std::vector< libtorrent::digest32< 256 > > > *)new_std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::vector< libtorrent::digest32< 256 > > const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doSize((std::vector< std::vector< libtorrent::digest32< 256 > > > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  arg2 = *(std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doAdd__SWIG_0(arg1,(std::vector< libtorrent::digest32< 256 > > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::vector< libtorrent::digest32< 256 > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type **)&jresult = new std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type *) &std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type *arg3 = 0 ;
  std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::vector< libtorrent::digest32< 256 > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type **)&jresult = new std::vector< std::vector< libtorrent::digest32< 256 > > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1sha256_1hash_1vector_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::vector< libtorrent::digest32< 256 > > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::vector< libtorrent::digest32< 256 > > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1udp_1endpoint_1pair_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *)new std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1udp_1endpoint_1pair_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *)new std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >((std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1udp_1endpoint_1pair_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > *arg2 = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *)new_std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doSize((std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  arg2 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doAdd__SWIG_0(arg1,(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type **)&jresult = new std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type *) &std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type *arg3 = 0 ;
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type **)&jresult = new std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_libtorrent_digest32_Sl_160_Sg__Sc_libtorrent_udp_endpoint_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1sha1_1hash_1udp_1endpoint_1pair_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::pair< libtorrent::digest32< 160 >,libtorrent::udp::endpoint > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1address_1sha1_1hash_1pair_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *)new std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1address_1sha1_1hash_1pair_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *)new std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >((std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1address_1sha1_1hash_1pair_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::pair< libtorrent::address,libtorrent::digest32< 160 > > *arg2 = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(std::pair< libtorrent::address,libtorrent::digest32< 160 > > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< libtorrent::address,libtorrent::digest32< 160 > > const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *)new_std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::pair< libtorrent::address,libtorrent::digest32< 160 > > const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doSize((std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  arg2 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doAdd__SWIG_0(arg1,(std::pair< libtorrent::address,libtorrent::digest32< 160 > > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::pair< libtorrent::address,libtorrent::digest32< 160 > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type **)&jresult = new std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type *) &std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type *arg3 = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::pair< libtorrent::address,libtorrent::digest32< 160 > > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type **)&jresult = new std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_digest32_Sl_160_Sg__Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1address_1sha1_1hash_1pair_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::digest32< 160 > > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1array_132_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::array< std::int8_t,32 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::array< std::int8_t,32 > *)new std::array< std::int8_t,32 >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::array< std::int8_t,32 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1array_132_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::array< std::int8_t,32 > *arg1 = 0 ;
  std::array< std::int8_t,32 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,32 > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::array< std::int8_t,32 > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::array< std::int8_t,32 > *)new std::array< std::int8_t,32 >((std::array< std::int8_t,32 > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::array< std::int8_t,32 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1array_132_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::array< std::int8_t,32 > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,32 > **)&jarg1; 
  {
    try {
      result = (bool)((std::array< std::int8_t,32 > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1array_132_1fill(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jbyte jarg2) {
  std::array< std::int8_t,32 > *arg1 = 0 ;
  std::int8_t *arg2 = 0 ;
  std::int8_t temp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,32 > **)&jarg1; 
  temp2 = (std::int8_t)jarg2; 
  arg2 = &temp2; 
  {
    try {
      (arg1)->fill((std::int8_t const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1array_132_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::array< std::int8_t,32 > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,32 > **)&jarg1; 
  {
    try {
      try {
        result = std_array_Sl_std_int8_t_Sc_32_Sg__size((std::array< signed char,32 > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1array_132_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jbyte jresult = 0 ;
  std::array< std::int8_t,32 > *arg1 = 0 ;
  int arg2 ;
  std::array< signed char,32 >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,32 > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::array< signed char,32 >::value_type *) &std_array_Sl_std_int8_t_Sc_32_Sg__get(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)*result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1array_132_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jbyte jarg3) {
  std::array< std::int8_t,32 > *arg1 = 0 ;
  int arg2 ;
  std::array< signed char,32 >::value_type *arg3 = 0 ;
  std::array< signed char,32 >::value_type temp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,32 > **)&jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (std::array< signed char,32 >::value_type)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_array_Sl_std_int8_t_Sc_32_Sg__set(arg1,arg2,(signed char const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1byte_1array_132(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::array< std::int8_t,32 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::array< std::int8_t,32 > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1array_164_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::array< std::int8_t,64 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::array< std::int8_t,64 > *)new std::array< std::int8_t,64 >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::array< std::int8_t,64 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1array_164_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::array< std::int8_t,64 > *arg1 = 0 ;
  std::array< std::int8_t,64 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,64 > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::array< std::int8_t,64 > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::array< std::int8_t,64 > *)new std::array< std::int8_t,64 >((std::array< std::int8_t,64 > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::array< std::int8_t,64 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1array_164_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::array< std::int8_t,64 > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,64 > **)&jarg1; 
  {
    try {
      result = (bool)((std::array< std::int8_t,64 > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1array_164_1fill(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jbyte jarg2) {
  std::array< std::int8_t,64 > *arg1 = 0 ;
  std::int8_t *arg2 = 0 ;
  std::int8_t temp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,64 > **)&jarg1; 
  temp2 = (std::int8_t)jarg2; 
  arg2 = &temp2; 
  {
    try {
      (arg1)->fill((std::int8_t const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1array_164_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::array< std::int8_t,64 > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,64 > **)&jarg1; 
  {
    try {
      try {
        result = std_array_Sl_std_int8_t_Sc_64_Sg__size((std::array< signed char,64 > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1array_164_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jbyte jresult = 0 ;
  std::array< std::int8_t,64 > *arg1 = 0 ;
  int arg2 ;
  std::array< signed char,64 >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,64 > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::array< signed char,64 >::value_type *) &std_array_Sl_std_int8_t_Sc_64_Sg__get(arg1,arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)*result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1array_164_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jbyte jarg3) {
  std::array< std::int8_t,64 > *arg1 = 0 ;
  int arg2 ;
  std::array< signed char,64 >::value_type *arg3 = 0 ;
  std::array< signed char,64 >::value_type temp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::array< std::int8_t,64 > **)&jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (std::array< signed char,64 >::value_type)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_array_Sl_std_int8_t_Sc_64_Sg__set(arg1,arg2,(signed char const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1byte_1array_164(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::array< std::int8_t,64 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::array< std::int8_t,64 > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1string_1map_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< int,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::map< int,std::string > *)new std::map< int,std::string >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1string_1map_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< int,std::string > *arg1 = 0 ;
  std::map< int,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< int,std::string > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::map< int,std::string > *)new std::map< int,std::string >((std::map< int,std::string > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< int,std::string >::iterator *arg1 = 0 ;
  std::map< int,std::string,std::less< int > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_int_Sc_std_string_Sg__iterator_getNextUnchecked(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,std::string,std::less< int > >::iterator **)&jresult = new std::map< int,std::string,std::less< int > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< int,std::string >::iterator *arg1 = 0 ;
  std::map< int,std::string >::iterator arg2 ;
  std::map< int,std::string >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< int,std::string >::iterator **)&jarg1; 
  argp2 = *(std::map< int,std::string >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< int,std::string >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)std_map_Sl_int_Sc_std_string_Sg__iterator_isNot((std::map< int,std::string >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< int,std::string >::iterator *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string >::iterator **)&jarg1; 
  {
    try {
      result = (int)std_map_Sl_int_Sc_std_string_Sg__iterator_getKey((std::map< int,std::string >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< int,std::string >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_int_Sc_std_string_Sg__iterator_getValue((std::map< int,std::string >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  std::map< int,std::string >::iterator *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string >::iterator **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      std_map_Sl_int_Sc_std_string_Sg__iterator_setValue(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1int_1string_1map_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< int,std::string >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< int,std::string >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< int,std::string > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string > **)&jarg1; 
  {
    try {
      result = (bool)((std::map< int,std::string > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< int,std::string > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::map< int,std::string > *arg1 = 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  std::map< int,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string > **)&jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (arg1)->find((int const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,std::string >::iterator **)&jresult = new std::map< int,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< int,std::string > *arg1 = 0 ;
  std::map< int,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string > **)&jarg1; 
  {
    try {
      result = (arg1)->begin();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,std::string >::iterator **)&jresult = new std::map< int,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< int,std::string > *arg1 = 0 ;
  std::map< int,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string > **)&jarg1; 
  {
    try {
      result = (arg1)->end();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,std::string >::iterator **)&jresult = new std::map< int,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< int,std::string > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string > **)&jarg1; 
  {
    try {
      try {
        result = std_map_Sl_int_Sc_std_string_Sg__sizeImpl((std::map< int,std::string > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jboolean jresult = 0 ;
  std::map< int,std::string > *arg1 = 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string > **)&jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_map_Sl_int_Sc_std_string_Sg__containsImpl(arg1,(int const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
  std::map< int,std::string > *arg1 = 0 ;
  int *arg2 = 0 ;
  std::string *arg3 = 0 ;
  int temp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,std::string > **)&jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      std_map_Sl_int_Sc_std_string_Sg__putUnchecked(arg1,(int const &)*arg2,(std::string const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1string_1map_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< int,std::string > *arg1 = 0 ;
  std::map< int,std::string,std::less< int > >::iterator arg2 ;
  std::map< int,std::string,std::less< int > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< int,std::string > **)&jarg1; 
  argp2 = *(std::map< int,std::string,std::less< int > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< int,std::string,std::less< int > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      std_map_Sl_int_Sc_std_string_Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1int_1string_1map(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< int,std::string > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< int,std::string > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1string_1map_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< std::string,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1string_1map_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::map< std::string,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< std::string,std::string > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::map< std::string,std::string > *)new std::map< std::string,std::string >((std::map< std::string,std::string > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  std::map< std::string,std::string,std::less< std::string > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_std_string_Sc_std_string_Sg__iterator_getNextUnchecked(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,std::string,std::less< std::string > >::iterator **)&jresult = new std::map< std::string,std::string,std::less< std::string > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  std::map< std::string,std::string >::iterator arg2 ;
  std::map< std::string,std::string >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  argp2 = *(std::map< std::string,std::string >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::string >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__iterator_isNot((std::map< std::string,std::string >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_std_string_Sc_std_string_Sg__iterator_getKey((std::map< std::string,std::string >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_std_string_Sc_std_string_Sg__iterator_getValue((std::map< std::string,std::string >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      std_map_Sl_std_string_Sc_std_string_Sg__iterator_setValue(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1string_1map_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::string >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::string >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  {
    try {
      result = (bool)((std::map< std::string,std::string > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< std::string,std::string > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::map< std::string,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (arg1)->find((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,std::string >::iterator **)&jresult = new std::map< std::string,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::map< std::string,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  {
    try {
      result = (arg1)->begin();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,std::string >::iterator **)&jresult = new std::map< std::string,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::map< std::string,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  {
    try {
      result = (arg1)->end();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,std::string >::iterator **)&jresult = new std::map< std::string,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  {
    try {
      try {
        result = std_map_Sl_std_string_Sc_std_string_Sg__sizeImpl((std::map< std::string,std::string > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,std::string > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (bool)std_map_Sl_std_string_Sc_std_string_Sg__containsImpl(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
  std::map< std::string,std::string > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      std_map_Sl_std_string_Sc_std_string_Sg__putUnchecked(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1map_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,std::string > *arg1 = 0 ;
  std::map< std::string,std::string,std::less< std::string > >::iterator arg2 ;
  std::map< std::string,std::string,std::less< std::string > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  argp2 = *(std::map< std::string,std::string,std::less< std::string > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,std::string,std::less< std::string > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      std_map_Sl_std_string_Sc_std_string_Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1string_1map(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,std::string > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,std::string > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1bitfield_1map_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< int,libtorrent::bitfield > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::map< int,libtorrent::bitfield > *)new std::map< int,libtorrent::bitfield >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,libtorrent::bitfield > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1int_1bitfield_1map_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< int,libtorrent::bitfield > *arg1 = 0 ;
  std::map< int,libtorrent::bitfield > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,libtorrent::bitfield > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< int,libtorrent::bitfield > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::map< int,libtorrent::bitfield > *)new std::map< int,libtorrent::bitfield >((std::map< int,libtorrent::bitfield > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,libtorrent::bitfield > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< int,libtorrent::bitfield >::iterator *arg1 = 0 ;
  std::map< int,libtorrent::bitfield,std::less< int > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,libtorrent::bitfield >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_int_Sc_libtorrent_bitfield_Sg__iterator_getNextUnchecked(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,libtorrent::bitfield,std::less< int > >::iterator **)&jresult = new std::map< int,libtorrent::bitfield,std::less< int > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< int,libtorrent::bitfield >::iterator *arg1 = 0 ;
  std::map< int,libtorrent::bitfield >::iterator arg2 ;
  std::map< int,libtorrent::bitfield >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< int,libtorrent::bitfield >::iterator **)&jarg1; 
  argp2 = *(std::map< int,libtorrent::bitfield >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< int,libtorrent::bitfield >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)std_map_Sl_int_Sc_libtorrent_bitfield_Sg__iterator_isNot((std::map< int,libtorrent::bitfield >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< int,libtorrent::bitfield >::iterator *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,libtorrent::bitfield >::iterator **)&jarg1; 
  {
    try {
      result = (int)std_map_Sl_int_Sc_libtorrent_bitfield_Sg__iterator_getKey((std::map< int,libtorrent::bitfield >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< int,libtorrent::bitfield >::iterator *arg1 = 0 ;
  libtorrent::bitfield result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,libtorrent::bitfield >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_int_Sc_libtorrent_bitfield_Sg__iterator_getValue((std::map< int,libtorrent::bitfield >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bitfield **)&jresult = new libtorrent::bitfield(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< int,libtorrent::bitfield >::iterator *arg1 = 0 ;
  libtorrent::bitfield *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< int,libtorrent::bitfield >::iterator **)&jarg1; 
  arg2 = *(libtorrent::bitfield **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bitfield const & is null");
    return ;
  } 
  {
    try {
      std_map_Sl_int_Sc_libtorrent_bitfield_Sg__iterator_setValue(arg1,(libtorrent::bitfield const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1int_1bitfield_1map_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< int,libtorrent::bitfield >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< int,libtorrent::bitfield >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< int,libtorrent::bitfield > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,libtorrent::bitfield > **)&jarg1; 
  {
    try {
      result = (bool)((std::map< int,libtorrent::bitfield > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< int,libtorrent::bitfield > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,libtorrent::bitfield > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::map< int,libtorrent::bitfield > *arg1 = 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  std::map< int,libtorrent::bitfield >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,libtorrent::bitfield > **)&jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (arg1)->find((int const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,libtorrent::bitfield >::iterator **)&jresult = new std::map< int,libtorrent::bitfield >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< int,libtorrent::bitfield > *arg1 = 0 ;
  std::map< int,libtorrent::bitfield >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,libtorrent::bitfield > **)&jarg1; 
  {
    try {
      result = (arg1)->begin();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,libtorrent::bitfield >::iterator **)&jresult = new std::map< int,libtorrent::bitfield >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< int,libtorrent::bitfield > *arg1 = 0 ;
  std::map< int,libtorrent::bitfield >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,libtorrent::bitfield > **)&jarg1; 
  {
    try {
      result = (arg1)->end();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,libtorrent::bitfield >::iterator **)&jresult = new std::map< int,libtorrent::bitfield >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< int,libtorrent::bitfield > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,libtorrent::bitfield > **)&jarg1; 
  {
    try {
      try {
        result = std_map_Sl_int_Sc_libtorrent_bitfield_Sg__sizeImpl((std::map< int,libtorrent::bitfield > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jboolean jresult = 0 ;
  std::map< int,libtorrent::bitfield > *arg1 = 0 ;
  int *arg2 = 0 ;
  int temp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< int,libtorrent::bitfield > **)&jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  {
    try {
      result = (bool)std_map_Sl_int_Sc_libtorrent_bitfield_Sg__containsImpl(arg1,(int const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::map< int,libtorrent::bitfield > *arg1 = 0 ;
  int *arg2 = 0 ;
  libtorrent::bitfield *arg3 = 0 ;
  int temp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::map< int,libtorrent::bitfield > **)&jarg1; 
  temp2 = (int)jarg2; 
  arg2 = &temp2; 
  arg3 = *(libtorrent::bitfield **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bitfield const & is null");
    return ;
  } 
  {
    try {
      std_map_Sl_int_Sc_libtorrent_bitfield_Sg__putUnchecked(arg1,(int const &)*arg2,(libtorrent::bitfield const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1bitfield_1map_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< int,libtorrent::bitfield > *arg1 = 0 ;
  std::map< int,libtorrent::bitfield,std::less< int > >::iterator arg2 ;
  std::map< int,libtorrent::bitfield,std::less< int > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< int,libtorrent::bitfield > **)&jarg1; 
  argp2 = *(std::map< int,libtorrent::bitfield,std::less< int > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< int,libtorrent::bitfield,std::less< int > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      std_map_Sl_int_Sc_libtorrent_bitfield_Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1int_1bitfield_1map(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< int,libtorrent::bitfield > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< int,libtorrent::bitfield > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1entry_1map_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< std::string,libtorrent::entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::map< std::string,libtorrent::entry > *)new std::map< std::string,libtorrent::entry >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,libtorrent::entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1entry_1map_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::map< std::string,libtorrent::entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< std::string,libtorrent::entry > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::map< std::string,libtorrent::entry > *)new std::map< std::string,libtorrent::entry >((std::map< std::string,libtorrent::entry > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,libtorrent::entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,libtorrent::entry >::iterator *arg1 = 0 ;
  std::map< std::string,libtorrent::entry,std::less< std::string > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_std_string_Sc_libtorrent_entry_Sg__iterator_getNextUnchecked(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,libtorrent::entry,std::less< std::string > >::iterator **)&jresult = new std::map< std::string,libtorrent::entry,std::less< std::string > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< std::string,libtorrent::entry >::iterator *arg1 = 0 ;
  std::map< std::string,libtorrent::entry >::iterator arg2 ;
  std::map< std::string,libtorrent::entry >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,libtorrent::entry >::iterator **)&jarg1; 
  argp2 = *(std::map< std::string,libtorrent::entry >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,libtorrent::entry >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)std_map_Sl_std_string_Sc_libtorrent_entry_Sg__iterator_isNot((std::map< std::string,libtorrent::entry >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,libtorrent::entry >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_std_string_Sc_libtorrent_entry_Sg__iterator_getKey((std::map< std::string,libtorrent::entry >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,libtorrent::entry >::iterator *arg1 = 0 ;
  libtorrent::entry result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_std_string_Sc_libtorrent_entry_Sg__iterator_getValue((std::map< std::string,libtorrent::entry >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = new libtorrent::entry(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,libtorrent::entry >::iterator *arg1 = 0 ;
  libtorrent::entry *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,libtorrent::entry >::iterator **)&jarg1; 
  arg2 = *(libtorrent::entry **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry const & is null");
    return ;
  } 
  {
    try {
      std_map_Sl_std_string_Sc_libtorrent_entry_Sg__iterator_setValue(arg1,(libtorrent::entry const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1entry_1map_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,libtorrent::entry >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,libtorrent::entry >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      result = (bool)((std::map< std::string,libtorrent::entry > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< std::string,libtorrent::entry > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::map< std::string,libtorrent::entry >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (arg1)->find((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,libtorrent::entry >::iterator **)&jresult = new std::map< std::string,libtorrent::entry >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::map< std::string,libtorrent::entry >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      result = (arg1)->begin();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,libtorrent::entry >::iterator **)&jresult = new std::map< std::string,libtorrent::entry >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::map< std::string,libtorrent::entry >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      result = (arg1)->end();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,libtorrent::entry >::iterator **)&jresult = new std::map< std::string,libtorrent::entry >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      try {
        result = std_map_Sl_std_string_Sc_libtorrent_entry_Sg__sizeImpl((std::map< std::string,libtorrent::entry > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (bool)std_map_Sl_std_string_Sc_libtorrent_entry_Sg__containsImpl(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  std::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  libtorrent::entry *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(libtorrent::entry **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry const & is null");
    return ;
  } 
  {
    try {
      std_map_Sl_std_string_Sc_libtorrent_entry_Sg__putUnchecked(arg1,(std::string const &)*arg2,(libtorrent::entry const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::map< std::string,libtorrent::entry,std::less< std::string > >::iterator arg2 ;
  std::map< std::string,libtorrent::entry,std::less< std::string > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  argp2 = *(std::map< std::string,libtorrent::entry,std::less< std::string > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,libtorrent::entry,std::less< std::string > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      std_map_Sl_std_string_Sc_libtorrent_entry_Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1entry_1map(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,libtorrent::entry > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_boost_1string_1entry_1map_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  boost::container::map< std::string,libtorrent::entry > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::container::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      result = (bool)((boost::container::map< std::string,libtorrent::entry > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_boost_1string_1entry_1map_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  boost::container::map< std::string,libtorrent::entry > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::container::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_boost_1string_1entry_1map_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  boost::container::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::container::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      result = (std::int64_t)((boost::container::map< std::string,libtorrent::entry > const *)arg1)->size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_boost_1string_1entry_1map_1contains(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  boost::container::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::container::map< std::string,libtorrent::entry > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (bool)boost_container_map_Sl_std_string_Sc_libtorrent_entry_Sg__contains(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_boost_1string_1entry_1map_1put(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  boost::container::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  libtorrent::entry *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(boost::container::map< std::string,libtorrent::entry > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(libtorrent::entry **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry & is null");
    return ;
  } 
  {
    try {
      boost_container_map_Sl_std_string_Sc_libtorrent_entry_Sg__put(arg1,(std::string const &)*arg2,*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_boost_1string_1entry_1map_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  boost::container::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::container::map< std::string,libtorrent::entry > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (libtorrent::entry *) &boost_container_map_Sl_std_string_Sc_libtorrent_entry_Sg__get(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_boost_1string_1entry_1map_1keys(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  boost::container::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::vector< std::string > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::container::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      result = boost_container_map_Sl_std_string_Sc_libtorrent_entry_Sg__keys(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::string > **)&jresult = new std::vector< std::string >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_boost_1string_1entry_1map_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  boost::container::map< std::string,libtorrent::entry > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::container::map< std::string,libtorrent::entry > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      boost_container_map_Sl_std_string_Sc_libtorrent_entry_Sg__remove(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1boost_1string_1entry_1map(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  boost::container::map< std::string,libtorrent::entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::container::map< std::string,libtorrent::entry > *)new boost::container::map< std::string,libtorrent::entry >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(boost::container::map< std::string,libtorrent::entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1boost_1string_1entry_1map(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  boost::container::map< std::string,libtorrent::entry > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(boost::container::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1index_1string_1map_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::map< libtorrent::file_index_t,std::string > *)new std::map< libtorrent::file_index_t,std::string >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< libtorrent::file_index_t,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1index_1string_1map_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string > *arg1 = 0 ;
  std::map< libtorrent::file_index_t,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< libtorrent::file_index_t,std::string > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::map< libtorrent::file_index_t,std::string > *)new std::map< libtorrent::file_index_t,std::string >((std::map< libtorrent::file_index_t,std::string > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< libtorrent::file_index_t,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string >::iterator *arg1 = 0 ;
  std::map< libtorrent::file_index_t,std::string,std::less< libtorrent::file_index_t > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__iterator_getNextUnchecked(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< libtorrent::file_index_t,std::string,std::less< libtorrent::file_index_t > >::iterator **)&jresult = new std::map< libtorrent::file_index_t,std::string,std::less< libtorrent::file_index_t > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string >::iterator *arg1 = 0 ;
  std::map< libtorrent::file_index_t,std::string >::iterator arg2 ;
  std::map< libtorrent::file_index_t,std::string >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string >::iterator **)&jarg1; 
  argp2 = *(std::map< libtorrent::file_index_t,std::string >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< libtorrent::file_index_t,std::string >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__iterator_isNot((std::map< libtorrent::file_index_t,std::string >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string >::iterator *arg1 = 0 ;
  libtorrent::file_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__iterator_getKey((std::map< libtorrent::file_index_t,std::string >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_index_t **)&jresult = new libtorrent::file_index_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__iterator_getValue((std::map< libtorrent::file_index_t,std::string >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  std::map< libtorrent::file_index_t,std::string >::iterator *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string >::iterator **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__iterator_setValue(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1index_1string_1map_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< libtorrent::file_index_t,std::string >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< libtorrent::file_index_t,std::string >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string > **)&jarg1; 
  {
    try {
      result = (bool)((std::map< libtorrent::file_index_t,std::string > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< libtorrent::file_index_t,std::string > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jlong jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string > *arg1 = 0 ;
  libtorrent::file_index_t *arg2 = 0 ;
  std::map< libtorrent::file_index_t,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string > **)&jarg1; 
  arg2 = *(libtorrent::file_index_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_index_t const & is null");
    return 0;
  } 
  {
    try {
      result = (arg1)->find((libtorrent::file_index_t const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< libtorrent::file_index_t,std::string >::iterator **)&jresult = new std::map< libtorrent::file_index_t,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string > *arg1 = 0 ;
  std::map< libtorrent::file_index_t,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string > **)&jarg1; 
  {
    try {
      result = (arg1)->begin();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< libtorrent::file_index_t,std::string >::iterator **)&jresult = new std::map< libtorrent::file_index_t,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string > *arg1 = 0 ;
  std::map< libtorrent::file_index_t,std::string >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string > **)&jarg1; 
  {
    try {
      result = (arg1)->end();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< libtorrent::file_index_t,std::string >::iterator **)&jresult = new std::map< libtorrent::file_index_t,std::string >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string > **)&jarg1; 
  {
    try {
      try {
        result = std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__sizeImpl((std::map< libtorrent::file_index_t,std::string > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jboolean jresult = 0 ;
  std::map< libtorrent::file_index_t,std::string > *arg1 = 0 ;
  libtorrent::file_index_t *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string > **)&jarg1; 
  arg2 = *(libtorrent::file_index_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_index_t const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__containsImpl(arg1,(libtorrent::file_index_t const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jstring jarg3) {
  std::map< libtorrent::file_index_t,std::string > *arg1 = 0 ;
  libtorrent::file_index_t *arg2 = 0 ;
  std::string *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string > **)&jarg1; 
  arg2 = *(libtorrent::file_index_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_index_t const & is null");
    return ;
  } 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__putUnchecked(arg1,(libtorrent::file_index_t const &)*arg2,(std::string const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< libtorrent::file_index_t,std::string > *arg1 = 0 ;
  std::map< libtorrent::file_index_t,std::string,std::less< libtorrent::file_index_t > >::iterator arg2 ;
  std::map< libtorrent::file_index_t,std::string,std::less< libtorrent::file_index_t > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< libtorrent::file_index_t,std::string > **)&jarg1; 
  argp2 = *(std::map< libtorrent::file_index_t,std::string,std::less< libtorrent::file_index_t > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< libtorrent::file_index_t,std::string,std::less< libtorrent::file_index_t > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      std_map_Sl_libtorrent_file_index_t_Sc_std_string_Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1index_1string_1map(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< libtorrent::file_index_t,std::string > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< libtorrent::file_index_t,std::string > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1index_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::file_index_t > *)new std::vector< libtorrent::file_index_t >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1index_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  std::vector< libtorrent::file_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::file_index_t > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::file_index_t > *)new std::vector< libtorrent::file_index_t >((std::vector< libtorrent::file_index_t > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::file_index_t > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1index_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::file_index_t *arg2 = 0 ;
  std::vector< libtorrent::file_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  arg2 = *(libtorrent::file_index_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_index_t const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::file_index_t > *)new_std_vector_Sl_libtorrent_file_index_t_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::file_index_t const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_file_index_t_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_file_index_t_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_file_index_t_Sg__doSize((std::vector< libtorrent::file_index_t > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  std::vector< libtorrent::file_index_t >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::file_index_t >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::file_index_t >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_file_index_t_Sg__doAdd__SWIG_0(arg1,(libtorrent::file_index_t const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::file_index_t >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::file_index_t >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::file_index_t >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_file_index_t_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::file_index_t const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::file_index_t >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_file_index_t_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_index_t >::value_type **)&jresult = new std::vector< libtorrent::file_index_t >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::file_index_t >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::file_index_t >::value_type *) &std_vector_Sl_libtorrent_file_index_t_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_index_t >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::file_index_t >::value_type *arg3 = 0 ;
  std::vector< libtorrent::file_index_t >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::file_index_t >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::file_index_t >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_file_index_t_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::file_index_t const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_index_t >::value_type **)&jresult = new std::vector< libtorrent::file_index_t >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_file_index_t_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1index_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::file_index_t > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::file_index_t > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1int_1pair_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::pair< piece_index_t,int > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< piece_index_t,int > *)new std::pair< piece_index_t,int >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< piece_index_t,int > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1int_1pair_1_1SWIG_11(JNIEnv *jenv, jclass jcls, int jarg1, jint jarg2) {
  jlong jresult = 0 ;
  piece_index_t arg1 ;
  int arg2 ;
  std::pair< piece_index_t,int > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    arg1 = piece_index_t(static_cast<std::int32_t>(jarg1));
  }
  arg2 = (int)jarg2; 
  {
    try {
      result = (std::pair< piece_index_t,int > *)new std::pair< piece_index_t,int >(SWIG_STD_MOVE(arg1),arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< piece_index_t,int > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1int_1pair_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< piece_index_t,int > *arg1 = 0 ;
  std::pair< piece_index_t,int > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< piece_index_t,int > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< piece_index_t,int > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< piece_index_t,int > *)new std::pair< piece_index_t,int >((std::pair< piece_index_t,int > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< piece_index_t,int > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1first_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  std::pair< piece_index_t,int > *arg1 = 0 ;
  piece_index_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< piece_index_t,int > **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  if (arg1) (arg1)->first = arg2;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1first_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  std::pair< piece_index_t,int > *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< piece_index_t,int > **)&jarg1; 
  result =  ((arg1)->first);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1second_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::pair< piece_index_t,int > *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< piece_index_t,int > **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->second = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1second_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::pair< piece_index_t,int > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< piece_index_t,int > **)&jarg1; 
  result = (int) ((arg1)->second);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1piece_1index_1int_1pair(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::pair< piece_index_t,int > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< piece_index_t,int > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1int_1pair_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::pair< libtorrent::piece_index_t,int > > *)new std::vector< std::pair< libtorrent::piece_index_t,int > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1int_1pair_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::piece_index_t,int > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< std::pair< libtorrent::piece_index_t,int > > *)new std::vector< std::pair< libtorrent::piece_index_t,int > >((std::vector< std::pair< libtorrent::piece_index_t,int > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::pair< libtorrent::piece_index_t,int > > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1int_1pair_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  std::pair< libtorrent::piece_index_t,int > *arg2 = 0 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  arg2 = *(std::pair< libtorrent::piece_index_t,int > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< libtorrent::piece_index_t,int > const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< std::pair< libtorrent::piece_index_t,int > > *)new_std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(std::pair< libtorrent::piece_index_t,int > const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doSize((std::vector< std::pair< libtorrent::piece_index_t,int > > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  arg2 = *(std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doAdd__SWIG_0(arg1,(std::pair< libtorrent::piece_index_t,int > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(std::pair< libtorrent::piece_index_t,int > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  jint arg2 ;
  SwigValueWrapper< std::pair< libtorrent::piece_index_t,int > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type **)&jresult = new std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type *) &std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type *arg3 = 0 ;
  SwigValueWrapper< std::pair< libtorrent::piece_index_t,int > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(std::pair< libtorrent::piece_index_t,int > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type **)&jresult = new std::vector< std::pair< libtorrent::piece_index_t,int > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_libtorrent_piece_index_t_Sc_int_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1piece_1index_1int_1pair_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::pair< libtorrent::piece_index_t,int > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::pair< libtorrent::piece_index_t,int > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::piece_index_t > *)new std::vector< libtorrent::piece_index_t >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  std::vector< libtorrent::piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::piece_index_t > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::piece_index_t > *)new std::vector< libtorrent::piece_index_t >((std::vector< libtorrent::piece_index_t > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::piece_index_t > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::piece_index_t *arg2 = 0 ;
  std::vector< libtorrent::piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = jarg1; 
  arg2 = *(libtorrent::piece_index_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::piece_index_t const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::piece_index_t > *)new_std_vector_Sl_libtorrent_piece_index_t_Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::piece_index_t const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_piece_index_t_Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_piece_index_t_Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_piece_index_t_Sg__doSize((std::vector< libtorrent::piece_index_t > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  std::vector< libtorrent::piece_index_t >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::piece_index_t >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::piece_index_t >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_piece_index_t_Sg__doAdd__SWIG_0(arg1,(libtorrent::piece_index_t const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::piece_index_t >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::piece_index_t >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::piece_index_t >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_piece_index_t_Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::piece_index_t const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::piece_index_t >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_piece_index_t_Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_index_t >::value_type **)&jresult = new std::vector< libtorrent::piece_index_t >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::piece_index_t >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::piece_index_t >::value_type *) &std_vector_Sl_libtorrent_piece_index_t_Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_index_t >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::piece_index_t >::value_type *arg3 = 0 ;
  std::vector< libtorrent::piece_index_t >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::piece_index_t >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::piece_index_t >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_piece_index_t_Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::piece_index_t const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::piece_index_t >::value_type **)&jresult = new std::vector< libtorrent::piece_index_t >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_piece_index_t_Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1piece_1index_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::piece_index_t > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::piece_index_t > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1long_1map_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::map< std::string,long > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::map< std::string,long > *)new std::map< std::string,long >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,long > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1long_1map_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,long > *arg1 = 0 ;
  std::map< std::string,long > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< std::string,long > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::map< std::string,long > *)new std::map< std::string,long >((std::map< std::string,long > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,long > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1Iterator_1getNextUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,long >::iterator *arg1 = 0 ;
  std::map< std::string,long,std::less< std::string > >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_std_string_Sc_long_Sg__iterator_getNextUnchecked(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,long,std::less< std::string > >::iterator **)&jresult = new std::map< std::string,long,std::less< std::string > >::iterator(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1Iterator_1isNot(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  std::map< std::string,long >::iterator *arg1 = 0 ;
  std::map< std::string,long >::iterator arg2 ;
  std::map< std::string,long >::iterator *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,long >::iterator **)&jarg1; 
  argp2 = *(std::map< std::string,long >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,long >::iterator");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)std_map_Sl_std_string_Sc_long_Sg__iterator_isNot((std::map< std::string,long >::iterator const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1Iterator_1getKey(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  std::map< std::string,long >::iterator *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long >::iterator **)&jarg1; 
  {
    try {
      result = std_map_Sl_std_string_Sc_long_Sg__iterator_getKey((std::map< std::string,long >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1Iterator_1getValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< std::string,long >::iterator *arg1 = 0 ;
  long result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long >::iterator **)&jarg1; 
  {
    try {
      result = (long)std_map_Sl_std_string_Sc_long_Sg__iterator_getValue((std::map< std::string,long >::iterator const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1Iterator_1setValue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::map< std::string,long >::iterator *arg1 = 0 ;
  long *arg2 = 0 ;
  long temp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long >::iterator **)&jarg1; 
  temp2 = (long)jarg2; 
  arg2 = &temp2; 
  {
    try {
      std_map_Sl_std_string_Sc_long_Sg__iterator_setValue(arg1,(long const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1long_1map_1Iterator(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,long >::iterator *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,long >::iterator **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,long > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  {
    try {
      result = (bool)((std::map< std::string,long > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::map< std::string,long > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  std::map< std::string,long > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::map< std::string,long >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (arg1)->find((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,long >::iterator **)&jresult = new std::map< std::string,long >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1begin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,long > *arg1 = 0 ;
  std::map< std::string,long >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  {
    try {
      result = (arg1)->begin();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,long >::iterator **)&jresult = new std::map< std::string,long >::iterator(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1end(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,long > *arg1 = 0 ;
  std::map< std::string,long >::iterator result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  {
    try {
      result = (arg1)->end();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< std::string,long >::iterator **)&jresult = new std::map< std::string,long >::iterator(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1sizeImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::map< std::string,long > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  {
    try {
      try {
        result = std_map_Sl_std_string_Sc_long_Sg__sizeImpl((std::map< std::string,long > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1containsImpl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,long > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (bool)std_map_Sl_std_string_Sc_long_Sg__containsImpl(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1putUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
  std::map< std::string,long > *arg1 = 0 ;
  std::string *arg2 = 0 ;
  long *arg3 = 0 ;
  long temp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  temp3 = (long)jarg3; 
  arg3 = &temp3; 
  {
    try {
      std_map_Sl_std_string_Sc_long_Sg__putUnchecked(arg1,(std::string const &)*arg2,(long const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1removeUnchecked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::map< std::string,long > *arg1 = 0 ;
  std::map< std::string,long,std::less< std::string > >::iterator arg2 ;
  std::map< std::string,long,std::less< std::string > >::iterator const *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  argp2 = *(std::map< std::string,long,std::less< std::string > >::iterator **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::map< std::string,long,std::less< std::string > >::iterator const");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      std_map_Sl_std_string_Sc_long_Sg__removeUnchecked(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1long_1map(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< std::string,long > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1view_1bdecode_1node_1pair_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::pair< libtorrent::string_view,libtorrent::bdecode_node > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< libtorrent::string_view,libtorrent::bdecode_node > *)new std::pair< libtorrent::string_view,libtorrent::bdecode_node >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::string_view,libtorrent::bdecode_node > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1view_1bdecode_1node_1pair_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::string_view arg1 ;
  libtorrent::bdecode_node arg2 ;
  libtorrent::string_view *argp1 ;
  libtorrent::bdecode_node *argp2 ;
  std::pair< libtorrent::string_view,libtorrent::bdecode_node > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  argp1 = *(libtorrent::string_view **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return 0;
  }
  arg1 = *argp1; 
  argp2 = *(libtorrent::bdecode_node **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::bdecode_node");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (std::pair< libtorrent::string_view,libtorrent::bdecode_node > *)new std::pair< libtorrent::string_view,libtorrent::bdecode_node >(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::string_view,libtorrent::bdecode_node > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1view_1bdecode_1node_1pair_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::string_view,libtorrent::bdecode_node > *arg1 = 0 ;
  std::pair< libtorrent::string_view,libtorrent::bdecode_node > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::string_view,libtorrent::bdecode_node > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< libtorrent::string_view,libtorrent::bdecode_node > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< libtorrent::string_view,libtorrent::bdecode_node > *)new std::pair< libtorrent::string_view,libtorrent::bdecode_node >((std::pair< libtorrent::string_view,libtorrent::bdecode_node > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::string_view,libtorrent::bdecode_node > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1view_1bdecode_1node_1pair_1first_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::pair< libtorrent::string_view,libtorrent::bdecode_node > *arg1 = 0 ;
  libtorrent::string_view *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::string_view,libtorrent::bdecode_node > **)&jarg1; 
  arg2 = *(libtorrent::string_view **)&jarg2; 
  if (arg1) (arg1)->first = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1view_1bdecode_1node_1pair_1first_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::string_view,libtorrent::bdecode_node > *arg1 = 0 ;
  libtorrent::string_view *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::string_view,libtorrent::bdecode_node > **)&jarg1; 
  result = (libtorrent::string_view *)& ((arg1)->first);
  *(libtorrent::string_view **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1view_1bdecode_1node_1pair_1second_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::pair< libtorrent::string_view,libtorrent::bdecode_node > *arg1 = 0 ;
  libtorrent::bdecode_node *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::string_view,libtorrent::bdecode_node > **)&jarg1; 
  arg2 = *(libtorrent::bdecode_node **)&jarg2; 
  if (arg1) (arg1)->second = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1view_1bdecode_1node_1pair_1second_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< libtorrent::string_view,libtorrent::bdecode_node > *arg1 = 0 ;
  libtorrent::bdecode_node *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::string_view,libtorrent::bdecode_node > **)&jarg1; 
  result = (libtorrent::bdecode_node *)& ((arg1)->second);
  *(libtorrent::bdecode_node **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1view_1bdecode_1node_1pair(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::pair< libtorrent::string_view,libtorrent::bdecode_node > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< libtorrent::string_view,libtorrent::bdecode_node > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_1128_1test(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jboolean jresult = 0 ;
  std::bitset< 128 > *arg1 = 0 ;
  std::size_t arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 128 > **)&jarg1; 
  arg2 = (std::size_t)jarg2; 
  {
    try {
      result = (bool)((std::bitset< 128 > const *)arg1)->test(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_1128_1all(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::bitset< 128 > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 128 > **)&jarg1; 
  {
    try {
      result = (bool)((std::bitset< 128 > const *)arg1)->all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_1128_1any(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::bitset< 128 > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 128 > **)&jarg1; 
  {
    try {
      result = (bool)((std::bitset< 128 > const *)arg1)->any();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_1128_1none(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::bitset< 128 > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 128 > **)&jarg1; 
  {
    try {
      result = (bool)((std::bitset< 128 > const *)arg1)->none();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_1128_1count(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::bitset< 128 > *arg1 = 0 ;
  std::size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 128 > **)&jarg1; 
  {
    try {
      result = ((std::bitset< 128 > const *)arg1)->count();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_1128_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::bitset< 128 > *arg1 = 0 ;
  std::size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 128 > **)&jarg1; 
  {
    try {
      result = ((std::bitset< 128 > const *)arg1)->size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_1128_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jboolean jresult = 0 ;
  std::bitset< 128 > *arg1 = 0 ;
  std::size_t arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 128 > **)&jarg1; 
  arg2 = (std::size_t)jarg2; 
  {
    try {
      result = (bool)std_bitset_Sl_128_Sg__get(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bitset_1128(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::bitset< 128 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::bitset< 128 > *)new std::bitset< 128 >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::bitset< 128 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bitset_1128(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::bitset< 128 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::bitset< 128 > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_196_1test(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jboolean jresult = 0 ;
  std::bitset< 96 > *arg1 = 0 ;
  std::size_t arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 96 > **)&jarg1; 
  arg2 = (std::size_t)jarg2; 
  {
    try {
      result = (bool)((std::bitset< 96 > const *)arg1)->test(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_196_1all(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::bitset< 96 > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 96 > **)&jarg1; 
  {
    try {
      result = (bool)((std::bitset< 96 > const *)arg1)->all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_196_1any(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::bitset< 96 > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 96 > **)&jarg1; 
  {
    try {
      result = (bool)((std::bitset< 96 > const *)arg1)->any();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_196_1none(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::bitset< 96 > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 96 > **)&jarg1; 
  {
    try {
      result = (bool)((std::bitset< 96 > const *)arg1)->none();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_196_1count(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::bitset< 96 > *arg1 = 0 ;
  std::size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 96 > **)&jarg1; 
  {
    try {
      result = ((std::bitset< 96 > const *)arg1)->count();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_196_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::bitset< 96 > *arg1 = 0 ;
  std::size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 96 > **)&jarg1; 
  {
    try {
      result = ((std::bitset< 96 > const *)arg1)->size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitset_196_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jboolean jresult = 0 ;
  std::bitset< 96 > *arg1 = 0 ;
  std::size_t arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::bitset< 96 > **)&jarg1; 
  arg2 = (std::size_t)jarg2; 
  {
    try {
      result = (bool)std_bitset_Sl_96_Sg__get(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bitset_196(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::bitset< 96 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::bitset< 96 > *)new std::bitset< 96 >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::bitset< 96 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bitset_196(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::bitset< 96 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::bitset< 96 > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bandwidth_1state_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bandwidth_1state_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bandwidth_1state_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bandwidth_1state_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bandwidth_1state_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bandwidth_1state_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bandwidth_1state_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bandwidth_1state_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bandwidth_1state_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bandwidth_1state_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bandwidth_1state_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bandwidth_1state_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_bandwidth_state_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bandwidth_1state_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1create_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_create_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1create_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1peer_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_peer_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1peer_1source_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1source_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1source_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1source_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1source_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1source_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1source_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1source_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1source_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1source_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1source_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1source_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_peer_source_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1source_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1pex_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pex_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1pex_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1picker_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_picker_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1picker_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1write_1torrent_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_write_torrent_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1write_1torrent_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::write_torrent_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1error_1code(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  boost::system::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::error_code *)new boost::system::error_code();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(boost::system::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_error_1code_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  boost::system::error_code *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::error_code **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_error_1code_1value(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  boost::system::error_code *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::error_code **)&jarg1; 
  {
    try {
      result = (int)(arg1)->value();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_error_1code_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  boost::system::error_code *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::error_code **)&jarg1; 
  {
    try {
      result = (arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_error_1code_1failed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  boost::system::error_code *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::error_code **)&jarg1; 
  {
    try {
      result = (bool)(arg1)->failed();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_error_1code_1op_1bool(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  boost::system::error_code *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::error_code **)&jarg1; 
  {
    try {
      result = (bool)((boost::system::error_code const *)arg1)->operator bool();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1error_1code(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  boost::system::error_code *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(boost::system::error_code **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1span(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::span< char > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::span< char > *)new libtorrent::span< char >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::span< char > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1span_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::span< char > *arg1 = 0 ;
  size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char > **)&jarg1; 
  {
    try {
      result = ((libtorrent::span< char > const *)arg1)->size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1span_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::span< char > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char > **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::span< char > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1span_1front(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jbyte jresult = 0 ;
  libtorrent::span< char > *arg1 = 0 ;
  int8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char > **)&jarg1; 
  {
    try {
      result = (int8_t)((libtorrent::span< char > const *)arg1)->front();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1span_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jbyte jresult = 0 ;
  libtorrent::span< char > *arg1 = 0 ;
  int8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char > **)&jarg1; 
  {
    try {
      result = (int8_t)((libtorrent::span< char > const *)arg1)->back();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1span_1first(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jlong jresult = 0 ;
  libtorrent::span< char > *arg1 = 0 ;
  size_t arg2 ;
  libtorrent::span< char > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char > **)&jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try {
      result = ((libtorrent::span< char > const *)arg1)->first(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::span< char > **)&jresult = new libtorrent::span< char >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1span_1last(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jlong jresult = 0 ;
  libtorrent::span< char > *arg1 = 0 ;
  size_t arg2 ;
  libtorrent::span< char > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char > **)&jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try {
      result = ((libtorrent::span< char > const *)arg1)->last(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::span< char > **)&jresult = new libtorrent::span< char >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1span_1subspan_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jlong jresult = 0 ;
  libtorrent::span< char > *arg1 = 0 ;
  size_t arg2 ;
  libtorrent::span< char > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char > **)&jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try {
      result = ((libtorrent::span< char > const *)arg1)->subspan(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::span< char > **)&jresult = new libtorrent::span< char >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1span_1subspan_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  libtorrent::span< char > *arg1 = 0 ;
  size_t arg2 ;
  size_t arg3 ;
  libtorrent::span< char > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char > **)&jarg1; 
  arg2 = (size_t)jarg2; 
  arg3 = (size_t)jarg3; 
  {
    try {
      result = ((libtorrent::span< char > const *)arg1)->subspan(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::span< char > **)&jresult = new libtorrent::span< char >(result); 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1span_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jbyte jresult = 0 ;
  libtorrent::span< char > *arg1 = 0 ;
  size_t arg2 ;
  int8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char > **)&jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try {
      result = (int8_t)libtorrent_span_Sl_char_Sg__get(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1span_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jbyte jarg3) {
  libtorrent::span< char > *arg1 = 0 ;
  size_t arg2 ;
  int8_t arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char > **)&jarg1; 
  arg2 = (size_t)jarg2; 
  arg3 = (int8_t)jarg3; 
  {
    try {
      libtorrent_span_Sl_char_Sg__set(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1byte_1span(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::span< char > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::span< char > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1const_1span(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::span< char const > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::span< char const > *)new libtorrent::span< char const >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::span< char const > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1const_1span_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::span< char const > *arg1 = 0 ;
  size_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char const > **)&jarg1; 
  {
    try {
      result = ((libtorrent::span< char const > const *)arg1)->size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1const_1span_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::span< char const > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char const > **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::span< char const > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1const_1span_1front(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jbyte jresult = 0 ;
  libtorrent::span< char const > *arg1 = 0 ;
  int8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char const > **)&jarg1; 
  {
    try {
      result = (int8_t)((libtorrent::span< char const > const *)arg1)->front();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1const_1span_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jbyte jresult = 0 ;
  libtorrent::span< char const > *arg1 = 0 ;
  int8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char const > **)&jarg1; 
  {
    try {
      result = (int8_t)((libtorrent::span< char const > const *)arg1)->back();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1const_1span_1first(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jlong jresult = 0 ;
  libtorrent::span< char const > *arg1 = 0 ;
  size_t arg2 ;
  libtorrent::span< char const > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char const > **)&jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try {
      result = ((libtorrent::span< char const > const *)arg1)->first(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::span< char const > **)&jresult = new libtorrent::span< char const >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1const_1span_1last(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jlong jresult = 0 ;
  libtorrent::span< char const > *arg1 = 0 ;
  size_t arg2 ;
  libtorrent::span< char const > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char const > **)&jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try {
      result = ((libtorrent::span< char const > const *)arg1)->last(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::span< char const > **)&jresult = new libtorrent::span< char const >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1const_1span_1subspan_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jlong jresult = 0 ;
  libtorrent::span< char const > *arg1 = 0 ;
  size_t arg2 ;
  libtorrent::span< char const > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char const > **)&jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try {
      result = ((libtorrent::span< char const > const *)arg1)->subspan(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::span< char const > **)&jresult = new libtorrent::span< char const >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1const_1span_1subspan_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  libtorrent::span< char const > *arg1 = 0 ;
  size_t arg2 ;
  size_t arg3 ;
  libtorrent::span< char const > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char const > **)&jarg1; 
  arg2 = (size_t)jarg2; 
  arg3 = (size_t)jarg3; 
  {
    try {
      result = ((libtorrent::span< char const > const *)arg1)->subspan(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::span< char const > **)&jresult = new libtorrent::span< char const >(result); 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1const_1span_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jbyte jresult = 0 ;
  libtorrent::span< char const > *arg1 = 0 ;
  size_t arg2 ;
  int8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::span< char const > **)&jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try {
      result = (int8_t)libtorrent_span_Sl_char_SS_const_Sg__get(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1byte_1const_1span(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::span< char const > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::span< char const > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1address_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::address *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::address *)new libtorrent::address();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::address **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1address_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::address *arg1 = 0 ;
  libtorrent::address *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::address **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::address const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::address *)new libtorrent::address((libtorrent::address const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::address **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1is_1v4(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::address *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::address **)&jarg1; 
  {
    try {
      result = (bool)(arg1)->is_v4();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1is_1v6(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::address *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::address **)&jarg1; 
  {
    try {
      result = (bool)(arg1)->is_v6();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1to_1string(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::address *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::address **)&jarg1; 
  {
    try {
      result = (arg1)->to_string();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1is_1loopback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::address *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::address **)&jarg1; 
  {
    try {
      result = (bool)(arg1)->is_loopback();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1is_1unspecified(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::address *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::address **)&jarg1; 
  {
    try {
      result = (bool)(arg1)->is_unspecified();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1is_1multicast(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::address *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::address **)&jarg1; 
  {
    try {
      result = (bool)(arg1)->is_multicast();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1op_1lt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::address *arg1 = 0 ;
  libtorrent::address *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::address **)&jarg1; 
  arg2 = *(libtorrent::address **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::address const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)libtorrent_address_op_lt(arg1,(libtorrent::address const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1compare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jint jresult = 0 ;
  libtorrent::address *arg1 = 0 ;
  libtorrent::address *arg2 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::address **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::address const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::address **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::address const & is null");
    return 0;
  } 
  {
    try {
      result = (int)libtorrent_address_compare((libtorrent::address const &)*arg1,(libtorrent::address const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1from_1string(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::string *arg1 = 0 ;
  boost::system::error_code *arg2 = 0 ;
  libtorrent::address result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  std::string arg1_str(arg1_pstr);
  arg1 = &arg1_str;
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = *(boost::system::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "boost::system::error_code & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_address_from_string((std::string const &)*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::address **)&jresult = new libtorrent::address(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1hash_1code(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::address *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::address **)&jarg1; 
  {
    try {
      result = (int)libtorrent_address_hash_code(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1address(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::address *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::address **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1tcp_1endpoint_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::tcp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::tcp::endpoint *)new libtorrent::tcp::endpoint();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tcp::endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1tcp_1endpoint_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::address arg1 ;
  unsigned short arg2 ;
  libtorrent::address *argp1 ;
  libtorrent::tcp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(libtorrent::address **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::address");
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (unsigned short)jarg2; 
  {
    try {
      result = (libtorrent::tcp::endpoint *)new libtorrent::tcp::endpoint(SWIG_STD_MOVE(arg1),arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tcp::endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1tcp_1endpoint_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::tcp::endpoint *arg1 = 0 ;
  libtorrent::tcp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tcp::endpoint **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::tcp::endpoint const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::tcp::endpoint *)new libtorrent::tcp::endpoint((libtorrent::tcp::endpoint const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tcp::endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1port(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tcp::endpoint *arg1 = 0 ;
  unsigned short result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tcp::endpoint **)&jarg1; 
  {
    try {
      result = (unsigned short)(arg1)->port();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1address(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::tcp::endpoint *arg1 = 0 ;
  libtorrent::address result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tcp::endpoint **)&jarg1; 
  {
    try {
      result = (arg1)->address();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::address **)&jresult = new libtorrent::address(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1tcp_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::tcp::endpoint *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::tcp::endpoint **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1udp_1endpoint_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::udp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::udp::endpoint *)new libtorrent::udp::endpoint();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::udp::endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1udp_1endpoint_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::address arg1 ;
  unsigned short arg2 ;
  libtorrent::address *argp1 ;
  libtorrent::udp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(libtorrent::address **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::address");
    return 0;
  }
  arg1 = *argp1; 
  arg2 = (unsigned short)jarg2; 
  {
    try {
      result = (libtorrent::udp::endpoint *)new libtorrent::udp::endpoint(SWIG_STD_MOVE(arg1),arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::udp::endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1udp_1endpoint_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::udp::endpoint *arg1 = 0 ;
  libtorrent::udp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::udp::endpoint **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::udp::endpoint const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::udp::endpoint *)new libtorrent::udp::endpoint((libtorrent::udp::endpoint const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::udp::endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1port(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::udp::endpoint *arg1 = 0 ;
  unsigned short result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::udp::endpoint **)&jarg1; 
  {
    try {
      result = (unsigned short)(arg1)->port();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1address(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::udp::endpoint *arg1 = 0 ;
  libtorrent::address result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::udp::endpoint **)&jarg1; 
  {
    try {
      result = (arg1)->address();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::address **)&jresult = new libtorrent::address(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1udp_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::udp::endpoint *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::udp::endpoint **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1state_1nids_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht::dht_state *arg1 = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht::dht_state **)&jarg1; 
  arg2 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&jarg2; 
  if (arg1) (arg1)->nids = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1state_1nids_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht::dht_state *arg1 = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_state **)&jarg1; 
  result = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *)& ((arg1)->nids);
  *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1state_1nodes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht::dht_state *arg1 = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht::dht_state **)&jarg1; 
  arg2 = *(std::vector< libtorrent::udp::endpoint > **)&jarg2; 
  if (arg1) (arg1)->nodes = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1state_1nodes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht::dht_state *arg1 = 0 ;
  std::vector< libtorrent::udp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_state **)&jarg1; 
  result = (std::vector< libtorrent::udp::endpoint > *)& ((arg1)->nodes);
  *(std::vector< libtorrent::udp::endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1state_1nodes6_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht::dht_state *arg1 = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht::dht_state **)&jarg1; 
  arg2 = *(std::vector< libtorrent::udp::endpoint > **)&jarg2; 
  if (arg1) (arg1)->nodes6 = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1state_1nodes6_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht::dht_state *arg1 = 0 ;
  std::vector< libtorrent::udp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_state **)&jarg1; 
  result = (std::vector< libtorrent::udp::endpoint > *)& ((arg1)->nodes6);
  *(std::vector< libtorrent::udp::endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1state_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::dht::dht_state *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_state **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1dht_1state(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::dht::dht_state *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::dht::dht_state *)new libtorrent::dht::dht_state();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht::dht_state **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1state(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht::dht_state *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht::dht_state **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1client_1data_1t_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::client_data_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::client_data_t *)new libtorrent::client_data_t();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::client_data_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1client_1data_1t_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  jlong jresult = 0 ;
  void *arg1 = 0 ;
  libtorrent::client_data_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (void *)jarg1; 
  {
    try {
      result = (libtorrent::client_data_t *)new libtorrent::client_data_t(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::client_data_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_client_1data_1t_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::client_data_t *arg1 = 0 ;
  void *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::client_data_t **)&jarg1; 
  {
    try {
      result = (void *)libtorrent_client_data_t_get(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1client_1data_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::client_data_t *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::client_data_t **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1size(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::digest32< 160 >::difference_type result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::digest32< 160 >::SWIGTEMPLATEDISAMBIGUATOR size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::digest32< 160 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::digest32< 160 > *)new libtorrent::digest32< 160 >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 160 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  libtorrent::digest32< 160 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 160 > const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::digest32< 160 > *)new libtorrent::digest32< 160 >((libtorrent::digest32< 160 > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 160 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1max(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::digest32< 160 > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::digest32< 160 >::SWIGTEMPLATEDISAMBIGUATOR max();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 160 > **)&jresult = new libtorrent::digest32< 160 >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1min(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::digest32< 160 > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::digest32< 160 >::SWIGTEMPLATEDISAMBIGUATOR min();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 160 > **)&jresult = new libtorrent::digest32< 160 >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::digest32< 160 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1is_1all_1zeros(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::digest32< 160 > const *)arg1)->is_all_zeros();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1op_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  libtorrent::digest32< 160 > *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 160 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 160 > const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::digest32< 160 > const *)arg1)->operator ==((libtorrent::digest32< 160 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1op_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  libtorrent::digest32< 160 > *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 160 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 160 > const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::digest32< 160 > const *)arg1)->operator !=((libtorrent::digest32< 160 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1op_1lt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  libtorrent::digest32< 160 > *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 160 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 160 > const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::digest32< 160 > const *)arg1)->operator <((libtorrent::digest32< 160 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1count_1leading_1zeroes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::digest32< 160 > const *)arg1)->count_leading_zeroes();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1op_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  libtorrent::digest32< 160 > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  {
    try {
      result = ((libtorrent::digest32< 160 > const *)arg1)->operator ~();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 160 > **)&jresult = new libtorrent::digest32< 160 >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1op_1xor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  libtorrent::digest32< 160 > *arg2 = 0 ;
  libtorrent::digest32< 160 > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 160 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 160 > const & is null");
    return 0;
  } 
  {
    try {
      result = ((libtorrent::digest32< 160 > const *)arg1)->operator ^((libtorrent::digest32< 160 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 160 > **)&jresult = new libtorrent::digest32< 160 >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1op_1and(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  libtorrent::digest32< 160 > *arg2 = 0 ;
  libtorrent::digest32< 160 > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 160 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 160 > const & is null");
    return 0;
  } 
  {
    try {
      result = ((libtorrent::digest32< 160 > const *)arg1)->operator &((libtorrent::digest32< 160 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 160 > **)&jresult = new libtorrent::digest32< 160 >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  libtorrent::digest32< 160 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::digest32< 160 > *)new_libtorrent_digest32_Sl_160_Sg___SWIG_2((std::vector< signed char > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 160 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1assign(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::digest32< 160 > *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_digest32_Sl_160_Sg__assign(arg1,(std::vector< signed char > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1hash_1code(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_digest32_Sl_160_Sg__hash_code(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1to_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  std::vector< std::int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  {
    try {
      result = libtorrent_digest32_Sl_160_Sg__to_bytes(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = new std::vector< std::int8_t >(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1to_1hex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  {
    try {
      result = libtorrent_digest32_Sl_160_Sg__to_hex(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1from_1hex(JNIEnv *jenv, jclass jcls, jstring jarg1) {
  jlong jresult = 0 ;
  std::string arg1 ;
  libtorrent::digest32< 160 > result;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  {
    try {
      result = libtorrent_digest32_Sl_160_Sg__from_hex(SWIG_STD_MOVE(arg1));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 160 > **)&jresult = new libtorrent::digest32< 160 >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1compare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jint jresult = 0 ;
  libtorrent::digest32< 160 > *arg1 = 0 ;
  libtorrent::digest32< 160 > *arg2 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 160 > const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::digest32< 160 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 160 > const & is null");
    return 0;
  } 
  {
    try {
      result = (int)libtorrent_digest32_Sl_160_Sg__compare((libtorrent::digest32< 160 > const &)*arg1,(libtorrent::digest32< 160 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1sha1_1hash(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::digest32< 160 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::digest32< 160 > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1size(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::digest32< 256 >::difference_type result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::digest32< 256 >::SWIGTEMPLATEDISAMBIGUATOR size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha256_1hash_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::digest32< 256 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::digest32< 256 > *)new libtorrent::digest32< 256 >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 256 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha256_1hash_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  libtorrent::digest32< 256 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 256 > const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::digest32< 256 > *)new libtorrent::digest32< 256 >((libtorrent::digest32< 256 > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 256 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1max(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::digest32< 256 > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::digest32< 256 >::SWIGTEMPLATEDISAMBIGUATOR max();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 256 > **)&jresult = new libtorrent::digest32< 256 >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1min(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::digest32< 256 > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::digest32< 256 >::SWIGTEMPLATEDISAMBIGUATOR min();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 256 > **)&jresult = new libtorrent::digest32< 256 >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::digest32< 256 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1is_1all_1zeros(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::digest32< 256 > const *)arg1)->is_all_zeros();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1op_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  libtorrent::digest32< 256 > *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 256 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 256 > const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::digest32< 256 > const *)arg1)->operator ==((libtorrent::digest32< 256 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1op_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  libtorrent::digest32< 256 > *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 256 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 256 > const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::digest32< 256 > const *)arg1)->operator !=((libtorrent::digest32< 256 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1op_1lt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  libtorrent::digest32< 256 > *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 256 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 256 > const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::digest32< 256 > const *)arg1)->operator <((libtorrent::digest32< 256 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1count_1leading_1zeroes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::digest32< 256 > const *)arg1)->count_leading_zeroes();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1op_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  libtorrent::digest32< 256 > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  {
    try {
      result = ((libtorrent::digest32< 256 > const *)arg1)->operator ~();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 256 > **)&jresult = new libtorrent::digest32< 256 >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1op_1xor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  libtorrent::digest32< 256 > *arg2 = 0 ;
  libtorrent::digest32< 256 > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 256 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 256 > const & is null");
    return 0;
  } 
  {
    try {
      result = ((libtorrent::digest32< 256 > const *)arg1)->operator ^((libtorrent::digest32< 256 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 256 > **)&jresult = new libtorrent::digest32< 256 >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1op_1and(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  libtorrent::digest32< 256 > *arg2 = 0 ;
  libtorrent::digest32< 256 > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  arg2 = *(libtorrent::digest32< 256 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 256 > const & is null");
    return 0;
  } 
  {
    try {
      result = ((libtorrent::digest32< 256 > const *)arg1)->operator &((libtorrent::digest32< 256 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 256 > **)&jresult = new libtorrent::digest32< 256 >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha256_1hash_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  libtorrent::digest32< 256 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::digest32< 256 > *)new_libtorrent_digest32_Sl_256_Sg___SWIG_2((std::vector< signed char > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 256 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1assign(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::digest32< 256 > *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_digest32_Sl_256_Sg__assign(arg1,(std::vector< signed char > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1hash_1code(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_digest32_Sl_256_Sg__hash_code(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1to_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  std::vector< std::int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  {
    try {
      result = libtorrent_digest32_Sl_256_Sg__to_bytes(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = new std::vector< std::int8_t >(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1to_1hex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  {
    try {
      result = libtorrent_digest32_Sl_256_Sg__to_hex(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1from_1hex(JNIEnv *jenv, jclass jcls, jstring jarg1) {
  jlong jresult = 0 ;
  std::string arg1 ;
  libtorrent::digest32< 256 > result;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  {
    try {
      result = libtorrent_digest32_Sl_256_Sg__from_hex(SWIG_STD_MOVE(arg1));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::digest32< 256 > **)&jresult = new libtorrent::digest32< 256 >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1compare(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jint jresult = 0 ;
  libtorrent::digest32< 256 > *arg1 = 0 ;
  libtorrent::digest32< 256 > *arg2 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 256 > const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::digest32< 256 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 256 > const & is null");
    return 0;
  } 
  {
    try {
      result = (int)libtorrent_digest32_Sl_256_Sg__compare((libtorrent::digest32< 256 > const &)*arg1,(libtorrent::digest32< 256 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1sha256_1hash(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::digest32< 256 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::digest32< 256 > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::digest32< 160 > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::digest32< 160 > > *)new std::vector< libtorrent::digest32< 160 > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 160 > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  std::vector< libtorrent::digest32< 160 > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::digest32< 160 > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::digest32< 160 > > *)new std::vector< libtorrent::digest32< 160 > >((std::vector< libtorrent::digest32< 160 > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 160 > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::digest32< 160 > > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha1_1hash_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::digest32< 160 > *arg2 = 0 ;
  std::vector< libtorrent::digest32< 160 > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::digest32< 160 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 160 > const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::digest32< 160 > > *)new_std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::digest32< 160 > const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 160 > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doSize((std::vector< libtorrent::digest32< 160 > > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  std::vector< libtorrent::digest32< 160 > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::digest32< 160 > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::digest32< 160 > >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doAdd__SWIG_0(arg1,(libtorrent::digest32< 160 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::digest32< 160 > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::digest32< 160 > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::digest32< 160 > >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::digest32< 160 > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::digest32< 160 > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 160 > >::value_type **)&jresult = new std::vector< libtorrent::digest32< 160 > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::digest32< 160 > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::digest32< 160 > >::value_type *) &std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 160 > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::digest32< 160 > >::value_type *arg3 = 0 ;
  std::vector< libtorrent::digest32< 160 > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::digest32< 160 > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::digest32< 160 > >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::digest32< 160 > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 160 > >::value_type **)&jresult = new std::vector< libtorrent::digest32< 160 > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_digest32_Sl_160_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1sha1_1hash_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::digest32< 160 > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::digest32< 160 > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha256_1hash_1vector_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::digest32< 256 > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::digest32< 256 > > *)new std::vector< libtorrent::digest32< 256 > >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 256 > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha256_1hash_1vector_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  std::vector< libtorrent::digest32< 256 > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::digest32< 256 > > const & is null");
    return 0;
  } 
  {
    try {
      result = (std::vector< libtorrent::digest32< 256 > > *)new std::vector< libtorrent::digest32< 256 > >((std::vector< libtorrent::digest32< 256 > > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 256 > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1isEmpty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::digest32< 256 > > const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1sha256_1hash_1vector_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  jint arg1 ;
  libtorrent::digest32< 256 > *arg2 = 0 ;
  std::vector< libtorrent::digest32< 256 > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  arg1 = jarg1; 
  arg2 = *(libtorrent::digest32< 256 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::digest32< 256 > const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::vector< libtorrent::digest32< 256 > > *)new_std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg___SWIG_2(SWIG_STD_MOVE(arg1),(libtorrent::digest32< 256 > const &)*arg2);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 256 > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1doCapacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doCapacity(arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1doReserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  jint arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doReserve(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::length_error &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1doSize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  jint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doSize((std::vector< libtorrent::digest32< 256 > > const *)arg1);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1doAdd_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  std::vector< libtorrent::digest32< 256 > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::digest32< 256 > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::digest32< 256 > >::value_type const & is null");
    return ;
  } 
  {
    try {
      std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doAdd__SWIG_0(arg1,(libtorrent::digest32< 256 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1doAdd_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::digest32< 256 > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::digest32< 256 > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::digest32< 256 > >::value_type const & is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doAdd__SWIG_1(arg1,SWIG_STD_MOVE(arg2),(libtorrent::digest32< 256 > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1doRemove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::digest32< 256 > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doRemove(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 256 > >::value_type **)&jresult = new std::vector< libtorrent::digest32< 256 > >::value_type(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1doGet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::digest32< 256 > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  arg2 = jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::digest32< 256 > >::value_type *) &std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doGet(arg1,SWIG_STD_MOVE(arg2));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 256 > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1doSet(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  jint arg2 ;
  std::vector< libtorrent::digest32< 256 > >::value_type *arg3 = 0 ;
  std::vector< libtorrent::digest32< 256 > >::value_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = *(std::vector< libtorrent::digest32< 256 > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::digest32< 256 > >::value_type const & is null");
    return 0;
  } 
  {
    try {
      try {
        result = std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doSet(arg1,SWIG_STD_MOVE(arg2),(libtorrent::digest32< 256 > const &)*arg3);
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return 0;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::digest32< 256 > >::value_type **)&jresult = new std::vector< libtorrent::digest32< 256 > >::value_type(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha256_1hash_1vector_1doRemoveRange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  jint arg2 ;
  jint arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  arg2 = jarg2; 
  arg3 = jarg3; 
  {
    try {
      try {
        std_vector_Sl_libtorrent_digest32_Sl_256_Sg__Sg__doRemoveRange(arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
      } catch(std::out_of_range &_e) {
        SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, (&_e)->what());
        return ;
      }
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1sha256_1hash_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::digest32< 256 > > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::digest32< 256 > > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_num_1protocols_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::size_t result;
  
  (void)jenv;
  (void)jcls;
  result = libtorrent::num_protocols;
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1info_1hash_1t_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::info_hash_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::info_hash_t *)new libtorrent::info_hash_t();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::info_hash_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1info_1hash_1t_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::sha1_hash arg1 ;
  libtorrent::sha1_hash *argp1 ;
  libtorrent::info_hash_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(libtorrent::sha1_hash **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::sha1_hash");
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (libtorrent::info_hash_t *)new libtorrent::info_hash_t(SWIG_STD_MOVE(arg1));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::info_hash_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1info_1hash_1t_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::sha256_hash arg1 ;
  libtorrent::sha256_hash *argp1 ;
  libtorrent::info_hash_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(libtorrent::sha256_hash **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::sha256_hash");
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (libtorrent::info_hash_t *)new libtorrent::info_hash_t(SWIG_STD_MOVE(arg1));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::info_hash_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1info_1hash_1t_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::sha1_hash arg1 ;
  libtorrent::sha256_hash arg2 ;
  libtorrent::sha1_hash *argp1 ;
  libtorrent::sha256_hash *argp2 ;
  libtorrent::info_hash_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  argp1 = *(libtorrent::sha1_hash **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::sha1_hash");
    return 0;
  }
  arg1 = *argp1; 
  argp2 = *(libtorrent::sha256_hash **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::sha256_hash");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (libtorrent::info_hash_t *)new libtorrent::info_hash_t(SWIG_STD_MOVE(arg1),SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::info_hash_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1info_1hash_1t_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::info_hash_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::info_hash_t const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::info_hash_t *)new libtorrent::info_hash_t((libtorrent::info_hash_t const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::info_hash_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1has_1v1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::info_hash_t const *)arg1)->has_v1();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1has_1v2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::info_hash_t const *)arg1)->has_v2();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1has(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jboolean jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::protocol_version arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  arg2 = (libtorrent::protocol_version)jarg2; 
  {
    try {
      result = (bool)((libtorrent::info_hash_t const *)arg1)->has(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::protocol_version arg2 ;
  libtorrent::sha1_hash result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  arg2 = (libtorrent::protocol_version)jarg2; 
  {
    try {
      result = ((libtorrent::info_hash_t const *)arg1)->get(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::sha1_hash **)&jresult = new libtorrent::sha1_hash(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1get_1best(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::sha1_hash result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  {
    try {
      result = ((libtorrent::info_hash_t const *)arg1)->get_best();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::sha1_hash **)&jresult = new libtorrent::sha1_hash(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_op_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::info_hash_t *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::info_hash_t const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::info_hash_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::info_hash_t const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)operator !=((libtorrent::info_hash_t const &)*arg1,(libtorrent::info_hash_t const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_op_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::info_hash_t *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::info_hash_t const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::info_hash_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::info_hash_t const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)operator ==((libtorrent::info_hash_t const &)*arg1,(libtorrent::info_hash_t const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1op_1lt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::info_hash_t *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  arg2 = *(libtorrent::info_hash_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::info_hash_t const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::info_hash_t const *)arg1)->operator <((libtorrent::info_hash_t const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1v1_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->v1 = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1v1_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->v1);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1v2_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::sha256_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  arg2 = *(libtorrent::sha256_hash **)&jarg2; 
  if (arg1) (arg1)->v2 = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1v2_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::sha256_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  result = (libtorrent::sha256_hash *)& ((arg1)->v2);
  *(libtorrent::sha256_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1op_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::info_hash_t *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  arg2 = *(libtorrent::info_hash_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::info_hash_t const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)libtorrent_info_hash_t_op_eq((libtorrent::info_hash_t const *)arg1,(libtorrent::info_hash_t const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_info_1hash_1t_1op_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::info_hash_t *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  arg2 = *(libtorrent::info_hash_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::info_hash_t const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)libtorrent_info_hash_t_op_ne((libtorrent::info_hash_t const *)arg1,(libtorrent::info_hash_t const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1info_1hash_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::info_hash_t *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::info_hash_t **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1t_1mask_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::status_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::status_t)libtorrent::status_t::mask;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1t_1oversized_1file_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::status_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::status_t)libtorrent::status_t::oversized_file;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_op_1or(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
  jint jresult = 0 ;
  libtorrent::status_t arg1 ;
  libtorrent::status_t arg2 ;
  libtorrent::status_t result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (libtorrent::status_t)jarg1; 
  arg2 = (libtorrent::status_t)jarg2; 
  {
    try {
      result = (libtorrent::status_t)libtorrent::operator |(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_op_1and(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {
  jint jresult = 0 ;
  libtorrent::status_t arg1 ;
  libtorrent::status_t arg2 ;
  libtorrent::status_t result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (libtorrent::status_t)jarg1; 
  arg2 = (libtorrent::status_t)jarg2; 
  {
    try {
      result = (libtorrent::status_t)libtorrent::operator &(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_op_1inv(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jint jresult = 0 ;
  libtorrent::status_t arg1 ;
  libtorrent::status_t result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (libtorrent::status_t)jarg1; 
  {
    try {
      result = (libtorrent::status_t)libtorrent::operator ~(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bitfield_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::bitfield *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::bitfield *)new libtorrent::bitfield();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bitfield **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bitfield_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::bitfield *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = (libtorrent::bitfield *)new libtorrent::bitfield(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bitfield **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bitfield_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jboolean jarg2) {
  jlong jresult = 0 ;
  int arg1 ;
  bool arg2 ;
  libtorrent::bitfield *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (libtorrent::bitfield *)new libtorrent::bitfield(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bitfield **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bitfield_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::bitfield *arg1 = 0 ;
  libtorrent::bitfield *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bitfield const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::bitfield *)new libtorrent::bitfield((libtorrent::bitfield const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bitfield **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1op_1at(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jboolean jresult = 0 ;
  libtorrent::bitfield *arg1 = 0 ;
  int arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (bool)((libtorrent::bitfield const *)arg1)->operator [](arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1get_1bit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jboolean jresult = 0 ;
  libtorrent::bitfield *arg1 = 0 ;
  int arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (bool)((libtorrent::bitfield const *)arg1)->get_bit(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1clear_1bit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::bitfield *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      (arg1)->clear_bit(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1set_1bit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::bitfield *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      (arg1)->set_bit(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1all_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::bitfield *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::bitfield const *)arg1)->all_set();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1none_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::bitfield *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::bitfield const *)arg1)->none_set();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::bitfield *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::bitfield const *)arg1)->size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1num_1words(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::bitfield *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::bitfield const *)arg1)->num_words();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::bitfield *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::bitfield const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1swap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::bitfield *arg1 = 0 ;
  libtorrent::bitfield *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  arg2 = *(libtorrent::bitfield **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bitfield & is null");
    return ;
  } 
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1count(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::bitfield *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::bitfield const *)arg1)->count();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1find_1first_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::bitfield *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::bitfield const *)arg1)->find_first_set();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1find_1last_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::bitfield *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::bitfield const *)arg1)->find_last_clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1resize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
  libtorrent::bitfield *arg1 = 0 ;
  int arg2 ;
  bool arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      (arg1)->resize(arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1resize_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::bitfield *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      (arg1)->resize(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1set_1all(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::bitfield *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      (arg1)->set_all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1clear_1all(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::bitfield *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      (arg1)->clear_all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::bitfield *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bitfield_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  libtorrent::bitfield *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::bitfield *)new_libtorrent_bitfield__SWIG_4((std::vector< signed char > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bitfield **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bitfield_1assign(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::bitfield *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_bitfield_assign(arg1,(std::vector< signed char > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bitfield(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::bitfield *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::bitfield **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_operation_1name(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jstring jresult = 0 ;
  libtorrent::operation_t arg1 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (libtorrent::operation_t)jarg1; 
  {
    try {
      result = (char *)libtorrent::operation_name(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_libtorrent_1no_1error_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::error_code_enum result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::error_code_enum)libtorrent::errors::no_error;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_missing_1file_1sizes_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::error_code_enum result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::error_code_enum)libtorrent::errors::missing_file_sizes;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_http_1parse_1error_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::error_code_enum result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::error_code_enum)libtorrent::errors::http_parse_error;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_no_1i2p_1router_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::error_code_enum result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::error_code_enum)libtorrent::errors::no_i2p_router;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_no_1i2p_1endpoint_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::error_code_enum result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::error_code_enum)libtorrent::errors::no_i2p_endpoint;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1not_1available_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::error_code_enum result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::error_code_enum)libtorrent::errors::scrape_not_available;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_no_1entropy_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::error_code_enum result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::error_code_enum)libtorrent::errors::no_entropy;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1unknown_1version_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::error_code_enum result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::error_code_enum)libtorrent::errors::torrent_unknown_version;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_cont_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::cont;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ok_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::ok;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_created_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::created;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_accepted_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::accepted;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_no_1content_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::no_content;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_multiple_1choices_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::multiple_choices;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_moved_1permanently_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::moved_permanently;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_moved_1temporarily_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::moved_temporarily;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_not_1modified_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::not_modified;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bad_1request_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::bad_request;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_unauthorized_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::unauthorized;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_forbidden_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::forbidden;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_not_1found_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::not_found;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_internal_1server_1error_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::internal_server_error;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_not_1implemented_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::not_implemented;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bad_1gateway_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::bad_gateway;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_service_1unavailable_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::errors::http_errors result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::errors::http_errors)libtorrent::errors::service_unavailable;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_print_1error(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::error_code *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::error_code **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent::print_error((boost::system::error_code const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1message_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::announce_infohash *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->message = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1message_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  result = (std::string *) & ((arg1)->message);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1last_1error_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::announce_infohash *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2; 
  if (arg1) (arg1)->last_error = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1last_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->last_error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1scrape_1incomplete_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::announce_infohash *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->scrape_incomplete = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1scrape_1incomplete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  result = (int) ((arg1)->scrape_incomplete);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1scrape_1complete_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::announce_infohash *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->scrape_complete = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1scrape_1complete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  result = (int) ((arg1)->scrape_complete);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1scrape_1downloaded_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::announce_infohash *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->scrape_downloaded = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1scrape_1downloaded_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  result = (int) ((arg1)->scrape_downloaded);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1fails_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) {
  libtorrent::announce_infohash *arg1 = 0 ;
  std::uint8_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  arg2 = (std::uint8_t)jarg2; 
  if (arg1) (arg1)->fails = arg2;
}


SWIGEXPORT jshort JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1fails_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jshort jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  std::uint8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  result = (std::uint8_t) ((arg1)->fails);
  jresult = (jshort)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1updating_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::announce_infohash *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->updating = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1updating_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  result = (bool) ((arg1)->updating);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1start_1sent_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::announce_infohash *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->start_sent = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1start_1sent_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  result = (bool) ((arg1)->start_sent);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1complete_1sent_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::announce_infohash *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->complete_sent = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1complete_1sent_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  result = (bool) ((arg1)->complete_sent);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1triggered_1manually_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::announce_infohash *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->triggered_manually = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1triggered_1manually_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  result = (bool) ((arg1)->triggered_manually);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1get_1next_1announce(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  {
    try {
      result = (std::int64_t)libtorrent_announce_infohash_get_next_announce(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1infohash_1get_1min_1announce(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_infohash *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  {
    try {
      result = (std::int64_t)libtorrent_announce_infohash_get_min_announce(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1announce_1infohash(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::announce_infohash *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::announce_infohash **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1announce_1endpoint(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::announce_endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::announce_endpoint *)new libtorrent::announce_endpoint();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::announce_endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1local_1endpoint_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::announce_endpoint *arg1 = 0 ;
  libtorrent::tcp::endpoint *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  arg2 = *(libtorrent::tcp::endpoint **)&jarg2; 
  if (arg1) (arg1)->local_endpoint = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1local_1endpoint_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = 0 ;
  libtorrent::tcp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  result = (libtorrent::tcp::endpoint *)& ((arg1)->local_endpoint);
  *(libtorrent::tcp::endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1enabled_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::announce_endpoint *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->enabled = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1enabled_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  result = (bool) ((arg1)->enabled);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1get_1infohash_1v1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = 0 ;
  libtorrent::announce_infohash result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  {
    try {
      result = libtorrent_announce_endpoint_get_infohash_v1(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::announce_infohash **)&jresult = new libtorrent::announce_infohash(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1get_1infohash_1v2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = 0 ;
  libtorrent::announce_infohash result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  {
    try {
      result = libtorrent_announce_endpoint_get_infohash_v2(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::announce_infohash **)&jresult = new libtorrent::announce_infohash(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1announce_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::announce_endpoint *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1announce_1entry_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::announce_entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::announce_entry *)new libtorrent::announce_entry();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::announce_entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1announce_1entry(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::announce_entry *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1announce_1entry_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_entry *arg1 = 0 ;
  libtorrent::announce_entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::announce_entry const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::announce_entry *)new libtorrent::announce_entry((libtorrent::announce_entry const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::announce_entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1url_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::announce_entry *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->url = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1url_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::announce_entry *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  result = (std::string *) & ((arg1)->url);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1trackerid_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::announce_entry *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->trackerid = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1trackerid_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::announce_entry *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  result = (std::string *) & ((arg1)->trackerid);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1endpoints_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::announce_entry *arg1 = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  arg2 = *(std::vector< libtorrent::announce_endpoint > **)&jarg2; 
  if (arg1) (arg1)->endpoints = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1endpoints_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_entry *arg1 = 0 ;
  std::vector< libtorrent::announce_endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  result = (std::vector< libtorrent::announce_endpoint > *)& ((arg1)->endpoints);
  *(std::vector< libtorrent::announce_endpoint > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1tier_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) {
  libtorrent::announce_entry *arg1 = 0 ;
  std::uint8_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  arg2 = (std::uint8_t)jarg2; 
  if (arg1) (arg1)->tier = arg2;
}


SWIGEXPORT jshort JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1tier_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jshort jresult = 0 ;
  libtorrent::announce_entry *arg1 = 0 ;
  std::uint8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  result = (std::uint8_t) ((arg1)->tier);
  jresult = (jshort)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1fail_1limit_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) {
  libtorrent::announce_entry *arg1 = 0 ;
  std::uint8_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  arg2 = (std::uint8_t)jarg2; 
  if (arg1) (arg1)->fail_limit = arg2;
}


SWIGEXPORT jshort JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1fail_1limit_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jshort jresult = 0 ;
  libtorrent::announce_entry *arg1 = 0 ;
  std::uint8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  result = (std::uint8_t) ((arg1)->fail_limit);
  jresult = (jshort)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1source_1torrent_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::announce_entry::tracker_source result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::announce_entry::tracker_source)libtorrent::announce_entry::source_torrent;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1source_1client_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::announce_entry::tracker_source result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::announce_entry::tracker_source)libtorrent::announce_entry::source_client;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1source_1magnet_1link_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::announce_entry::tracker_source result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::announce_entry::tracker_source)libtorrent::announce_entry::source_magnet_link;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1source_1tex_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::announce_entry::tracker_source result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::announce_entry::tracker_source)libtorrent::announce_entry::source_tex;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1source_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) {
  libtorrent::announce_entry *arg1 = 0 ;
  std::uint8_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  arg2 = (std::uint8_t)jarg2; 
  if (arg1) (arg1)->source = arg2;
}


SWIGEXPORT jshort JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1source_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jshort jresult = 0 ;
  libtorrent::announce_entry *arg1 = 0 ;
  std::uint8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  result = (std::uint8_t) ((arg1)->source);
  jresult = (jshort)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1verified_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::announce_entry *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->verified = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1verified_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::announce_entry *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  result = (bool) ((arg1)->verified);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1announce_1entry_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1) {
  jlong jresult = 0 ;
  std::string arg1 ;
  libtorrent::announce_entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  {
    try {
      result = (libtorrent::announce_entry *)new_libtorrent_announce_entry__SWIG_2(SWIG_STD_MOVE(arg1));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::announce_entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1announce_1entry_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  libtorrent::announce_entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::announce_entry *)new_libtorrent_announce_entry__SWIG_3((std::vector< signed char > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::announce_entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1get_1url(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_entry *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  {
    try {
      result = libtorrent_announce_entry_get_url(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1set_1url(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::announce_entry *arg1 = 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_announce_entry_set_url(arg1,(std::vector< signed char > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1get_1trackerid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_entry *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  {
    try {
      result = libtorrent_announce_entry_get_trackerid(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1set_1trackerid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::announce_entry *arg1 = 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::announce_entry **)&jarg1; 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_announce_entry_set_trackerid(arg1,(std::vector< signed char > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1file_1index_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::file_slice *arg1 = 0 ;
  file_index_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_slice **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  if (arg1) (arg1)->file_index = arg2;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1file_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::file_slice *arg1 = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_slice **)&jarg1; 
  result =  ((arg1)->file_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1offset_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::file_slice *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_slice **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->offset = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1offset_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_slice *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_slice **)&jarg1; 
  result = (std::int64_t) ((arg1)->offset);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1size_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::file_slice *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_slice **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->size = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1size_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_slice *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_slice **)&jarg1; 
  result = (std::int64_t) ((arg1)->size);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1slice(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::file_slice *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::file_slice *)new libtorrent::file_slice();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_slice **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1slice(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::file_slice *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::file_slice **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1storage_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::file_storage *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::file_storage *)new libtorrent::file_storage();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_storage **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1storage(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::file_storage *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1storage_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  libtorrent::file_storage *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_storage const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::file_storage *)new libtorrent::file_storage((libtorrent::file_storage const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_storage **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1max_1file_1size_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  long long result;
  
  (void)jenv;
  (void)jcls;
  result = (long long)libtorrent::file_storage::max_file_size;
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1max_1file_1offset_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  long long result;
  
  (void)jenv;
  (void)jcls;
  result = (long long)libtorrent::file_storage::max_file_offset;
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1max_1num_1pieces_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::file_storage::max_num_pieces;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1max_1piece_1size_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::file_storage::max_piece_size;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1is_1valid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::file_storage const *)arg1)->is_valid();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::file_storage *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      (arg1)->reserve(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1rename_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jstring jarg3) {
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  std::string *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      (arg1)->rename_file(SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1map_1block(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jlong jarg3, jlong jarg4) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  piece_index_t arg2 ;
  std::int64_t arg3 ;
  std::int64_t arg4 ;
  std::vector< libtorrent::file_slice > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = (std::int64_t)jarg3; 
  arg4 = (std::int64_t)jarg4; 
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->map_block(SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_slice > **)&jresult = new std::vector< libtorrent::file_slice >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1map_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jlong jarg3, jint jarg4) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  std::int64_t arg3 ;
  int arg4 ;
  libtorrent::peer_request result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = (std::int64_t)jarg3; 
  arg4 = (int)jarg4; 
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->map_file(SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_request **)&jresult = new libtorrent::peer_request(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1num_1files(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::file_storage const *)arg1)->num_files();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1end_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->end_file();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1total_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = (std::int64_t)((libtorrent::file_storage const *)arg1)->total_size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1set_1num_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::file_storage *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      (arg1)->set_num_pieces(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1num_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::file_storage const *)arg1)->num_pieces();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1end_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->end_piece();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1last_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->last_piece();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1set_1piece_1length(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::file_storage *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      (arg1)->set_piece_length(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1piece_1length(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::file_storage const *)arg1)->piece_length();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1piece_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jint jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  piece_index_t arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (int)((libtorrent::file_storage const *)arg1)->piece_size(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1piece_1size2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jint jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  piece_index_t arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (int)((libtorrent::file_storage const *)arg1)->piece_size2(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1blocks_1in_1piece2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jint jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  piece_index_t arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (int)((libtorrent::file_storage const *)arg1)->blocks_in_piece2(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1blocks_1per_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::file_storage const *)arg1)->blocks_per_piece();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1set_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::file_storage *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      (arg1)->set_name((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = (std::string *) &((libtorrent::file_storage const *)arg1)->name();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1swap(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::file_storage *arg1 = 0 ;
  libtorrent::file_storage *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = *(libtorrent::file_storage **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_storage & is null");
    return ;
  } 
  {
    try {
      (arg1)->swap(*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1canonicalize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::file_storage *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      (arg1)->canonicalize();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1hash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  libtorrent::sha1_hash result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->hash(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::sha1_hash **)&jresult = new libtorrent::sha1_hash(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1root(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  libtorrent::sha256_hash result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->root(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::sha256_hash **)&jresult = new libtorrent::sha256_hash(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1root_1ptr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jstring jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (char *)((libtorrent::file_storage const *)arg1)->root_ptr(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1symlink(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jstring jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->symlink(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1mtime(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  std::time_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->mtime(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1path_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jstring jarg3) {
  jstring jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  std::string *arg3 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return 0;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->file_path(SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1path_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jstring jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->file_path(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (std::int64_t)((libtorrent::file_storage const *)arg1)->file_size(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1pad_1file_1at(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jboolean jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (bool)((libtorrent::file_storage const *)arg1)->pad_file_at(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1offset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (std::int64_t)((libtorrent::file_storage const *)arg1)->file_offset(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1num_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jint jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (int)((libtorrent::file_storage const *)arg1)->file_num_pieces(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1num_1blocks(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jint jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (int)((libtorrent::file_storage const *)arg1)->file_num_blocks(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1first_1piece_1node(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jint jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (int)((libtorrent::file_storage const *)arg1)->file_first_piece_node(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1first_1block_1node(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jint jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (int)((libtorrent::file_storage const *)arg1)->file_first_block_node(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1flag_1pad_1file_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > *)&libtorrent::file_storage::flag_pad_file;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1flag_1hidden_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > *)&libtorrent::file_storage::flag_hidden;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1flag_1executable_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > *)&libtorrent::file_storage::flag_executable;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1flag_1symlink_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > *)&libtorrent::file_storage::flag_symlink;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  libtorrent::file_flags_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->file_flags(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_flags_t **)&jresult = new libtorrent::file_flags_t(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1absolute_1path(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jboolean jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (bool)((libtorrent::file_storage const *)arg1)->file_absolute_path(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1index_1at_1offset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  int jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  std::int64_t arg2 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->file_index_at_offset(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1index_1at_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  int jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  piece_index_t arg2 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->file_index_at_piece(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1index_1for_1root(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  int jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  libtorrent::sha256_hash *arg2 = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = *(libtorrent::sha256_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha256_hash const & is null");
    return 0;
  } 
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->file_index_for_root((libtorrent::sha256_hash const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1piece_1index_1at_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  int jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  file_index_t arg2 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->piece_index_at_file(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1v2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::file_storage const *)arg1)->v2();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1canonicalize_1impl(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::file_storage *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      (arg1)->canonicalize_impl(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1add_1file_1ex_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jlong jarg4, jlong jarg5, jobject jarg5_, jlong jarg6, jstring jarg7) {
  libtorrent::file_storage *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::int64_t arg4 ;
  libtorrent::file_flags_t arg5 ;
  std::time_t arg6 ;
  std::string arg7 ;
  libtorrent::file_flags_t *argp5 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg5_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return ;
  } 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  arg4 = (std::int64_t)jarg4; 
  argp5 = *(libtorrent::file_flags_t **)&jarg5; 
  if (!argp5) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::file_flags_t");
    return ;
  }
  arg5 = *argp5; 
  arg6 = (std::time_t)jarg6; 
  if(!jarg7) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  } 
  const char *arg7_pstr = jenv->GetStringUTFChars(jarg7, 0); 
  if (!arg7_pstr) return ;
  (&arg7)->assign(arg7_pstr);
  jenv->ReleaseStringUTFChars(jarg7, arg7_pstr); 
  {
    try {
      libtorrent_file_storage_add_file_ex__SWIG_0(arg1,*arg2,(std::string const &)*arg3,arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6),SWIG_STD_MOVE(arg7));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1add_1file_1ex_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jlong jarg4, jlong jarg5, jobject jarg5_, jlong jarg6) {
  libtorrent::file_storage *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::int64_t arg4 ;
  libtorrent::file_flags_t arg5 ;
  std::time_t arg6 ;
  libtorrent::file_flags_t *argp5 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg5_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return ;
  } 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  arg4 = (std::int64_t)jarg4; 
  argp5 = *(libtorrent::file_flags_t **)&jarg5; 
  if (!argp5) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::file_flags_t");
    return ;
  }
  arg5 = *argp5; 
  arg6 = (std::time_t)jarg6; 
  {
    try {
      libtorrent_file_storage_add_file_ex__SWIG_0(arg1,*arg2,(std::string const &)*arg3,arg4,SWIG_STD_MOVE(arg5),SWIG_STD_MOVE(arg6));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1add_1file_1ex_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jlong jarg4, jlong jarg5, jobject jarg5_) {
  libtorrent::file_storage *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::int64_t arg4 ;
  libtorrent::file_flags_t arg5 ;
  libtorrent::file_flags_t *argp5 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg5_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return ;
  } 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  arg4 = (std::int64_t)jarg4; 
  argp5 = *(libtorrent::file_flags_t **)&jarg5; 
  if (!argp5) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::file_flags_t");
    return ;
  }
  arg5 = *argp5; 
  {
    try {
      libtorrent_file_storage_add_file_ex__SWIG_0(arg1,*arg2,(std::string const &)*arg3,arg4,SWIG_STD_MOVE(arg5));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1add_1file_1ex_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jlong jarg4) {
  libtorrent::file_storage *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::int64_t arg4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return ;
  } 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  arg4 = (std::int64_t)jarg4; 
  {
    try {
      libtorrent_file_storage_add_file_ex__SWIG_0(arg1,*arg2,(std::string const &)*arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1name_1ex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jstring jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  int arg2 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = libtorrent_file_storage_file_name_ex(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1file_1paths_1ex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  std::vector< std::string > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = libtorrent_file_storage_file_paths_ex(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::string > **)&jresult = new std::vector< std::string >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1request_1piece_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::peer_request *arg1 = 0 ;
  piece_index_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_request **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  if (arg1) (arg1)->piece = arg2;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1request_1piece_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::peer_request *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_request **)&jarg1; 
  result =  ((arg1)->piece);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1request_1start_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_request *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_request **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->start = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1request_1start_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_request *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_request **)&jarg1; 
  result = (int) ((arg1)->start);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1request_1length_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_request *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_request **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->length = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1request_1length_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_request *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_request **)&jarg1; 
  result = (int) ((arg1)->length);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1request_1op_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::peer_request *arg1 = 0 ;
  libtorrent::peer_request *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_request **)&jarg1; 
  arg2 = *(libtorrent::peer_request **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::peer_request const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::peer_request const *)arg1)->operator ==((libtorrent::peer_request const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1peer_1request(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::peer_request *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::peer_request *)new libtorrent::peer_request();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_request **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1request(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_request *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_request **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1no_1error_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::bdecode_errors::error_code_enum result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::bdecode_errors::error_code_enum)libtorrent::bdecode_errors::no_error;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bdecode_1node_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::bdecode_node *)new libtorrent::bdecode_node();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bdecode_node **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bdecode_1node_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  libtorrent::bdecode_node *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::bdecode_node *)new libtorrent::bdecode_node((libtorrent::bdecode_node const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bdecode_node **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  libtorrent::bdecode_node::type_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      result = (libtorrent::bdecode_node::type_t)((libtorrent::bdecode_node const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1op_1bool(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::bdecode_node const *)arg1)->operator bool();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1data_1offset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::ptrdiff_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      result = ((libtorrent::bdecode_node const *)arg1)->data_offset();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1list_1at(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  int arg2 ;
  libtorrent::bdecode_node result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = ((libtorrent::bdecode_node const *)arg1)->list_at(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bdecode_node **)&jresult = new libtorrent::bdecode_node(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1list_1int_1value_1at_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  int arg2 ;
  std::int64_t arg3 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::int64_t)jarg3; 
  {
    try {
      result = (std::int64_t)((libtorrent::bdecode_node const *)arg1)->list_int_value_at(arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1list_1int_1value_1at_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  int arg2 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (std::int64_t)((libtorrent::bdecode_node const *)arg1)->list_int_value_at(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1list_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::bdecode_node const *)arg1)->list_size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1dict_1at_1node(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  int arg2 ;
  std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = ((libtorrent::bdecode_node const *)arg1)->dict_at_node(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node > **)&jresult = new std::pair< libtorrent::bdecode_node,libtorrent::bdecode_node >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1dict_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::bdecode_node const *)arg1)->dict_size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1int_1value(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      result = (std::int64_t)((libtorrent::bdecode_node const *)arg1)->int_value();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1string_1length(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::bdecode_node const *)arg1)->string_length();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1string_1offset(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::ptrdiff_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      result = ((libtorrent::bdecode_node const *)arg1)->string_offset();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::bdecode_node *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1list_1string_1value_1at_1s_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
  jstring jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  int arg2 ;
  std::string arg3 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  arg2 = (int)jarg2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return 0;
  (&arg3)->assign(arg3_pstr);
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      result = libtorrent_bdecode_node_list_string_value_at_s__SWIG_0(arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1list_1string_1value_1at_1s_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jstring jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  int arg2 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = libtorrent_bdecode_node_list_string_value_at_s__SWIG_0(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1dict_1find_1s(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::string arg2 ;
  libtorrent::bdecode_node result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = libtorrent_bdecode_node_dict_find_s((libtorrent::bdecode_node const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bdecode_node **)&jresult = new libtorrent::bdecode_node(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1dict_1find_1dict_1s(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::string arg2 ;
  libtorrent::bdecode_node result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = libtorrent_bdecode_node_dict_find_dict_s((libtorrent::bdecode_node const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bdecode_node **)&jresult = new libtorrent::bdecode_node(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1dict_1find_1list_1s(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::string arg2 ;
  libtorrent::bdecode_node result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = libtorrent_bdecode_node_dict_find_list_s((libtorrent::bdecode_node const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bdecode_node **)&jresult = new libtorrent::bdecode_node(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1dict_1find_1string_1s(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::string arg2 ;
  libtorrent::bdecode_node result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = libtorrent_bdecode_node_dict_find_string_s((libtorrent::bdecode_node const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bdecode_node **)&jresult = new libtorrent::bdecode_node(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1dict_1find_1int_1s(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::string arg2 ;
  libtorrent::bdecode_node result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = libtorrent_bdecode_node_dict_find_int_s((libtorrent::bdecode_node const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bdecode_node **)&jresult = new libtorrent::bdecode_node(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1dict_1find_1string_1value_1s_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
  jstring jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::string arg2 ;
  std::string arg3 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return 0;
  (&arg3)->assign(arg3_pstr);
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      result = libtorrent_bdecode_node_dict_find_string_value_s__SWIG_0((libtorrent::bdecode_node const *)arg1,SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1dict_1find_1string_1value_1s_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jstring jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::string arg2 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = libtorrent_bdecode_node_dict_find_string_value_s__SWIG_0((libtorrent::bdecode_node const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1dict_1find_1int_1value_1s_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::string arg2 ;
  std::int64_t arg3 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = (std::int64_t)jarg3; 
  {
    try {
      result = (std::int64_t)libtorrent_bdecode_node_dict_find_int_value_s__SWIG_0((libtorrent::bdecode_node const *)arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1dict_1find_1int_1value_1s_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::string arg2 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (std::int64_t)libtorrent_bdecode_node_dict_find_int_value_s__SWIG_0((libtorrent::bdecode_node const *)arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1string_1value_1s(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      result = libtorrent_bdecode_node_string_value_s((libtorrent::bdecode_node const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1string_1value_1ex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      result = libtorrent_bdecode_node_string_value_ex((libtorrent::bdecode_node const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1to_1string(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2, jint jarg3) {
  jstring jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  bool arg2 ;
  int arg3 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & is null");
    return 0;
  } 
  arg2 = jarg2 ? true : false; 
  arg3 = (int)jarg3; 
  {
    try {
      result = libtorrent_bdecode_node_to_string((libtorrent::bdecode_node const &)*arg1,arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1bdecode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  jint jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  libtorrent::bdecode_node *arg2 = 0 ;
  libtorrent::error_code *arg3 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  arg2 = *(libtorrent::bdecode_node **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node & is null");
    return 0;
  } 
  arg3 = *(libtorrent::error_code **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  {
    try {
      result = (int)libtorrent_bdecode_node_bdecode(*arg1,*arg2,*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bdecode_1node(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::bdecode_node *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::bdecode_node **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1web_1seed_1entry_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jstring jarg3, jlong jarg4, jobject jarg4_) {
  jlong jresult = 0 ;
  std::string arg1 ;
  libtorrent::web_seed_entry::type_t arg2 ;
  std::string arg3 ;
  libtorrent::web_seed_entry::headers_t arg4 ;
  libtorrent::web_seed_entry::headers_t *argp4 ;
  libtorrent::web_seed_entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg4_;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = (libtorrent::web_seed_entry::type_t)jarg2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return 0;
  (&arg3)->assign(arg3_pstr);
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  argp4 = *(libtorrent::web_seed_entry::headers_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::web_seed_entry::headers_t");
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (libtorrent::web_seed_entry *)new libtorrent::web_seed_entry(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::web_seed_entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1web_1seed_1entry_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jstring jarg3) {
  jlong jresult = 0 ;
  std::string arg1 ;
  libtorrent::web_seed_entry::type_t arg2 ;
  std::string arg3 ;
  libtorrent::web_seed_entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = (libtorrent::web_seed_entry::type_t)jarg2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return 0;
  (&arg3)->assign(arg3_pstr);
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      result = (libtorrent::web_seed_entry *)new libtorrent::web_seed_entry(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::web_seed_entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1web_1seed_1entry_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2) {
  jlong jresult = 0 ;
  std::string arg1 ;
  libtorrent::web_seed_entry::type_t arg2 ;
  libtorrent::web_seed_entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = (libtorrent::web_seed_entry::type_t)jarg2; 
  {
    try {
      result = (libtorrent::web_seed_entry *)new libtorrent::web_seed_entry(SWIG_STD_MOVE(arg1),arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::web_seed_entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1op_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::web_seed_entry *arg1 = 0 ;
  libtorrent::web_seed_entry *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::web_seed_entry **)&jarg1; 
  arg2 = *(libtorrent::web_seed_entry **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::web_seed_entry const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::web_seed_entry const *)arg1)->operator ==((libtorrent::web_seed_entry const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1op_1lt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::web_seed_entry *arg1 = 0 ;
  libtorrent::web_seed_entry *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::web_seed_entry **)&jarg1; 
  arg2 = *(libtorrent::web_seed_entry **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::web_seed_entry const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::web_seed_entry const *)arg1)->operator <((libtorrent::web_seed_entry const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1url_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::web_seed_entry *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::web_seed_entry **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->url = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1url_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::web_seed_entry *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::web_seed_entry **)&jarg1; 
  result = (std::string *) & ((arg1)->url);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1auth_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::web_seed_entry *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::web_seed_entry **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->auth = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1auth_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::web_seed_entry *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::web_seed_entry **)&jarg1; 
  result = (std::string *) & ((arg1)->auth);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1extra_1headers_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::web_seed_entry *arg1 = 0 ;
  libtorrent::web_seed_entry::headers_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::web_seed_entry **)&jarg1; 
  arg2 = *(libtorrent::web_seed_entry::headers_t **)&jarg2; 
  if (arg1) (arg1)->extra_headers = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1extra_1headers_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::web_seed_entry *arg1 = 0 ;
  libtorrent::web_seed_entry::headers_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::web_seed_entry **)&jarg1; 
  result = (libtorrent::web_seed_entry::headers_t *)& ((arg1)->extra_headers);
  *(libtorrent::web_seed_entry::headers_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1type_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) {
  libtorrent::web_seed_entry *arg1 = 0 ;
  std::uint8_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::web_seed_entry **)&jarg1; 
  arg2 = (std::uint8_t)jarg2; 
  if (arg1) (arg1)->type = arg2;
}


SWIGEXPORT jshort JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jshort jresult = 0 ;
  libtorrent::web_seed_entry *arg1 = 0 ;
  std::uint8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::web_seed_entry **)&jarg1; 
  result = (std::uint8_t) ((arg1)->type);
  jresult = (jshort)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1web_1seed_1entry(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::web_seed_entry *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::web_seed_entry **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_load_1torrent_1limits_1max_1buffer_1size_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::load_torrent_limits *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::load_torrent_limits **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_buffer_size = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_load_1torrent_1limits_1max_1buffer_1size_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::load_torrent_limits *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::load_torrent_limits **)&jarg1; 
  result = (int) ((arg1)->max_buffer_size);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_load_1torrent_1limits_1max_1pieces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::load_torrent_limits *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::load_torrent_limits **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_pieces = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_load_1torrent_1limits_1max_1pieces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::load_torrent_limits *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::load_torrent_limits **)&jarg1; 
  result = (int) ((arg1)->max_pieces);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_load_1torrent_1limits_1max_1decode_1depth_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::load_torrent_limits *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::load_torrent_limits **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_decode_depth = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_load_1torrent_1limits_1max_1decode_1depth_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::load_torrent_limits *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::load_torrent_limits **)&jarg1; 
  result = (int) ((arg1)->max_decode_depth);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_load_1torrent_1limits_1max_1decode_1tokens_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::load_torrent_limits *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::load_torrent_limits **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_decode_tokens = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_load_1torrent_1limits_1max_1decode_1tokens_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::load_torrent_limits *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::load_torrent_limits **)&jarg1; 
  result = (int) ((arg1)->max_decode_tokens);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1load_1torrent_1limits(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::load_torrent_limits *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::load_torrent_limits *)new libtorrent::load_torrent_limits();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::load_torrent_limits **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1load_1torrent_1limits(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::load_torrent_limits *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::load_torrent_limits **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1info_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  libtorrent::torrent_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_info const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::torrent_info *)new libtorrent::torrent_info((libtorrent::torrent_info const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1info_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::info_hash_t *arg1 = 0 ;
  libtorrent::torrent_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::info_hash_t **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::info_hash_t const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::torrent_info *)new libtorrent::torrent_info((libtorrent::info_hash_t const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1info_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  libtorrent::torrent_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::torrent_info *)new libtorrent::torrent_info((libtorrent::bdecode_node const &)*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1info_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::string *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  libtorrent::torrent_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  std::string arg1_str(arg1_pstr);
  arg1 = &arg1_str;
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::torrent_info *)new libtorrent::torrent_info((std::string const &)*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1info(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_info *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1files(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  libtorrent::file_storage *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (libtorrent::file_storage *) &((libtorrent::torrent_info const *)arg1)->files();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_storage **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1orig_1files(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  libtorrent::file_storage *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (libtorrent::file_storage *) &((libtorrent::torrent_info const *)arg1)->orig_files();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_storage **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1rename_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jstring jarg3) {
  libtorrent::torrent_info *arg1 = 0 ;
  file_index_t arg2 ;
  std::string *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      (arg1)->rename_file(SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1remap_1files(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_info *arg1 = 0 ;
  libtorrent::file_storage *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  arg2 = *(libtorrent::file_storage **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_storage const & is null");
    return ;
  } 
  {
    try {
      (arg1)->remap_files((libtorrent::file_storage const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1add_1tracker_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = (int)jarg3; 
  {
    try {
      (arg1)->add_tracker((std::string const &)*arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1add_1tracker_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      (arg1)->add_tracker((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1add_1tracker_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4) {
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  libtorrent::announce_entry::tracker_source arg4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = (int)jarg3; 
  arg4 = (libtorrent::announce_entry::tracker_source)jarg4; 
  {
    try {
      (arg1)->add_tracker((std::string const &)*arg2,arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1trackers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::vector< libtorrent::announce_entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (std::vector< libtorrent::announce_entry > *) &((libtorrent::torrent_info const *)arg1)->trackers();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1clear_1trackers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_info *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      (arg1)->clear_trackers();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1similar_1torrents_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::vector< libtorrent::sha1_hash > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_info const *)arg1)->similar_torrents();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::sha1_hash > **)&jresult = new std::vector< libtorrent::sha1_hash >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1collections(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::vector< std::string > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_info const *)arg1)->collections();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::string > **)&jresult = new std::vector< std::string >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1add_1url_1seed_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jlong jarg4, jobject jarg4_) {
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  libtorrent::web_seed_entry::headers_t *arg4 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg4_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  arg4 = *(libtorrent::web_seed_entry::headers_t **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::web_seed_entry::headers_t const & is null");
    return ;
  } 
  {
    try {
      (arg1)->add_url_seed((std::string const &)*arg2,(std::string const &)*arg3,(libtorrent::web_seed_entry::headers_t const &)*arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1add_1url_1seed_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      (arg1)->add_url_seed((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1add_1url_1seed_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      (arg1)->add_url_seed((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1add_1http_1seed_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jlong jarg4, jobject jarg4_) {
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  libtorrent::web_seed_entry::headers_t *arg4 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg4_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  arg4 = *(libtorrent::web_seed_entry::headers_t **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::web_seed_entry::headers_t const & is null");
    return ;
  } 
  {
    try {
      (arg1)->add_http_seed((std::string const &)*arg2,(std::string const &)*arg3,(libtorrent::web_seed_entry::headers_t const &)*arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1add_1http_1seed_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      (arg1)->add_http_seed((std::string const &)*arg2,(std::string const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1add_1http_1seed_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      (arg1)->add_http_seed((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1web_1seeds(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::vector< libtorrent::web_seed_entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (std::vector< libtorrent::web_seed_entry > *) &((libtorrent::torrent_info const *)arg1)->web_seeds();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::web_seed_entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1set_1web_1seeds(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_info *arg1 = 0 ;
  std::vector< libtorrent::web_seed_entry > arg2 ;
  std::vector< libtorrent::web_seed_entry > *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  argp2 = *(std::vector< libtorrent::web_seed_entry > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< libtorrent::web_seed_entry >");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      (arg1)->set_web_seeds(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1total_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (std::int64_t)((libtorrent::torrent_info const *)arg1)->total_size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1piece_1length(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_info const *)arg1)->piece_length();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1num_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_info const *)arg1)->num_pieces();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1blocks_1per_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_info const *)arg1)->blocks_per_piece();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1last_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_info const *)arg1)->last_piece();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1end_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_info const *)arg1)->end_piece();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1info_1hash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  libtorrent::sha1_hash result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_info const *)arg1)->info_hash();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::sha1_hash **)&jresult = new libtorrent::sha1_hash(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1info_1hashes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  libtorrent::info_hash_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (libtorrent::info_hash_t *) &((libtorrent::torrent_info const *)arg1)->info_hashes();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::info_hash_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1v1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::torrent_info const *)arg1)->v1();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1v2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::torrent_info const *)arg1)->v2();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1num_1files(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_info const *)arg1)->num_files();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1map_1block(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jlong jarg3, jint jarg4) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  piece_index_t arg2 ;
  std::int64_t arg3 ;
  int arg4 ;
  std::vector< libtorrent::file_slice > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = (std::int64_t)jarg3; 
  arg4 = (int)jarg4; 
  {
    try {
      result = ((libtorrent::torrent_info const *)arg1)->map_block(SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::file_slice > **)&jresult = new std::vector< libtorrent::file_slice >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1map_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jlong jarg3, jint jarg4) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  file_index_t arg2 ;
  std::int64_t arg3 ;
  int arg4 ;
  libtorrent::peer_request result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = (std::int64_t)jarg3; 
  arg4 = (int)jarg4; 
  {
    try {
      result = ((libtorrent::torrent_info const *)arg1)->map_file(SWIG_STD_MOVE(arg2),arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_request **)&jresult = new libtorrent::peer_request(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1is_1valid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::torrent_info const *)arg1)->is_valid();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1priv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::torrent_info const *)arg1)->priv();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1is_1i2p(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::torrent_info const *)arg1)->is_i2p();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1piece_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jint jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  piece_index_t arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (int)((libtorrent::torrent_info const *)arg1)->piece_size(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1hash_1for_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  piece_index_t arg2 ;
  libtorrent::sha1_hash result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = ((libtorrent::torrent_info const *)arg1)->hash_for_piece(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::sha1_hash **)&jresult = new libtorrent::sha1_hash(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1is_1loaded(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::torrent_info const *)arg1)->is_loaded();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (std::string *) &((libtorrent::torrent_info const *)arg1)->name();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1creation_1date(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::time_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_info const *)arg1)->creation_date();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1creator(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (std::string *) &((libtorrent::torrent_info const *)arg1)->creator();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1comment(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (std::string *) &((libtorrent::torrent_info const *)arg1)->comment();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1nodes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::vector< std::pair< std::string,int > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (std::vector< std::pair< std::string,int > > *) &((libtorrent::torrent_info const *)arg1)->nodes();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,int > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1add_1node(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_info *arg1 = 0 ;
  std::pair< std::string,int > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  arg2 = *(std::pair< std::string,int > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< std::string,int > const & is null");
    return ;
  } 
  {
    try {
      (arg1)->add_node((std::pair< std::string,int > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1info(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  char *arg2 = 0 ;
  libtorrent::bdecode_node result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  {
    try {
      result = ((libtorrent::torrent_info const *)arg1)->info((char const *)arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bdecode_node **)&jresult = new libtorrent::bdecode_node(result); 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1free_1piece_1layers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_info *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      (arg1)->free_piece_layers();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1info_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::int64_t arg1 ;
  int arg2 ;
  libtorrent::error_code *arg3 = 0 ;
  libtorrent::torrent_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg3_;
  arg1 = (std::int64_t)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(libtorrent::error_code **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::torrent_info *)new_libtorrent_torrent_info__SWIG_4(arg1,arg2,*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1get_1info_1section(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  SwigValueWrapper< libtorrent::span< signed char const > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = libtorrent_torrent_info_get_info_section(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::span< std::int8_t const > **)&jresult = new libtorrent::span< std::int8_t const >(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1get_1ssl_1cert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = libtorrent_torrent_info_get_ssl_cert(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_seed_1mode_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::seed_mode;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_upload_1mode_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::upload_mode;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_share_1mode_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::share_mode;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_apply_1ip_1filter_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::apply_ip_filter;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_paused_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::paused;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_auto_1managed_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::auto_managed;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_duplicate_1is_1error_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::duplicate_is_error;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_update_1subscribe_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::update_subscribe;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_super_1seeding_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::super_seeding;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sequential_1download_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::sequential_download;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stop_1when_1ready_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::stop_when_ready;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_override_1trackers_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::override_trackers;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_override_1web_1seeds_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::override_web_seeds;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_need_1save_1resume_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::need_save_resume;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_disable_1dht_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::disable_dht;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_disable_1lsd_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::disable_lsd;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_disable_1pex_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::disable_pex;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_no_1verify_1files_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::no_verify_files;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_default_1dont_1download_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::default_dont_download;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_i2p_1torrent_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::i2p_torrent;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_all_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::all;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_default_1flags_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_flags_t *)&libtorrent::torrent_flags::default_flags;
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint64_t_Sc_libtorrent_torrent_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1add_1torrent_1params(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1version_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->version = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1version_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (int) ((arg1)->version);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1name_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->name = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1name_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (std::string *) & ((arg1)->name);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1save_1path_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->save_path = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1save_1path_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (std::string *) & ((arg1)->save_path);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1storage_1mode_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::storage_mode_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (libtorrent::storage_mode_t)jarg2; 
  if (arg1) (arg1)->storage_mode = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1storage_1mode_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::storage_mode_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (libtorrent::storage_mode_t) ((arg1)->storage_mode);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1trackerid_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->trackerid = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1trackerid_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (std::string *) & ((arg1)->trackerid);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1flags_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::torrent_flags_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(libtorrent::torrent_flags_t **)&jarg2; 
  if (arg1) (arg1)->flags = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1flags_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (libtorrent::torrent_flags_t *)& ((arg1)->flags);
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1info_1hashes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::info_hash_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(libtorrent::info_hash_t **)&jarg2; 
  if (arg1) (arg1)->info_hashes = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1info_1hashes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::info_hash_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (libtorrent::info_hash_t *)& ((arg1)->info_hashes);
  *(libtorrent::info_hash_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1max_1uploads_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_uploads = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1max_1uploads_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (int) ((arg1)->max_uploads);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1max_1connections_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_connections = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1max_1connections_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (int) ((arg1)->max_connections);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1upload_1limit_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->upload_limit = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1upload_1limit_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (int) ((arg1)->upload_limit);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1download_1limit_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->download_limit = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1download_1limit_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (int) ((arg1)->download_limit);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1total_1uploaded_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_uploaded = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1total_1uploaded_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_uploaded);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1total_1downloaded_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_downloaded = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1total_1downloaded_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_downloaded);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1active_1time_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->active_time = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1active_1time_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (int) ((arg1)->active_time);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1finished_1time_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->finished_time = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1finished_1time_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (int) ((arg1)->finished_time);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1seeding_1time_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->seeding_time = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1seeding_1time_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (int) ((arg1)->seeding_time);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1added_1time_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::time_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (std::time_t)jarg2; 
  if (arg1) (arg1)->added_time = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1added_1time_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::time_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result =  ((arg1)->added_time);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1completed_1time_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::time_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (std::time_t)jarg2; 
  if (arg1) (arg1)->completed_time = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1completed_1time_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::time_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result =  ((arg1)->completed_time);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1last_1seen_1complete_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::time_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (std::time_t)jarg2; 
  if (arg1) (arg1)->last_seen_complete = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1last_1seen_1complete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::time_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result =  ((arg1)->last_seen_complete);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1num_1complete_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_complete = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1num_1complete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (int) ((arg1)->num_complete);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1num_1incomplete_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_incomplete = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1num_1incomplete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (int) ((arg1)->num_incomplete);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1num_1downloaded_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_downloaded = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1num_1downloaded_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (int) ((arg1)->num_downloaded);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1last_1download_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::time_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (std::time_t)jarg2; 
  if (arg1) (arg1)->last_download = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1last_1download_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::time_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result =  ((arg1)->last_download);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1last_1upload_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::time_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = (std::time_t)jarg2; 
  if (arg1) (arg1)->last_upload = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1last_1upload_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::time_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result =  ((arg1)->last_upload);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1ti_1ptr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::torrent_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_info *)libtorrent_add_torrent_params_ti_ptr(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1ti(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::torrent_info *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(libtorrent::torrent_info **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_info const & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_ti(arg1,(libtorrent::torrent_info const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1file_1priorities(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_file_priorities(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = new std::vector< std::int8_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1renamed_1files_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::map< file_index_t,std::string,std::less< file_index_t > > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::map< file_index_t,std::string,std::less< file_index_t > > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< file_index_t,std::string,std::less< file_index_t > > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_renamed_files__SWIG_0(arg1,(std::map< file_index_t,std::string,std::less< file_index_t > > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1renamed_1files_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::map< int,std::string,std::less< int > > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::map< int,std::string,std::less< int > > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< int,std::string,std::less< int > > & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_renamed_files__SWIG_1(arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1tracker_1tiers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< int > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_tracker_tiers(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int > **)&jresult = new std::vector< int >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1tracker_1tiers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< int > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< int > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_tracker_tiers(arg1,(std::vector< int > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1banned_1peers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< libtorrent::tcp::endpoint > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_banned_peers(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::tcp::endpoint > **)&jresult = new std::vector< libtorrent::tcp::endpoint >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1banned_1peers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::tcp::endpoint > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_banned_peers(arg1,(std::vector< libtorrent::tcp::endpoint > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1peers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< libtorrent::tcp::endpoint > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_peers(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::tcp::endpoint > **)&jresult = new std::vector< libtorrent::tcp::endpoint >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1peers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::tcp::endpoint > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_peers(arg1,(std::vector< libtorrent::tcp::endpoint > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1file_1priorities2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_file_priorities2(arg1,(std::vector< signed char > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1file_1priorities(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_file_priorities(arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1piece_1priorities(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_piece_priorities(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = new std::vector< std::int8_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1piece_1priorities(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_piece_priorities(arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1dht_1nodes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::pair< std::string,int > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_dht_nodes(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< std::string,int > > **)&jresult = new std::vector< std::pair< std::string,int > >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1dht_1nodes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::pair< std::string,int > > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< std::pair< std::string,int > > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< std::string,int > > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_dht_nodes(arg1,(std::vector< std::pair< std::string,int > > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1http_1seeds(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< std::string > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_http_seeds(arg1,(std::vector< std::string > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1url_1seeds(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::string > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_url_seeds(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::string > **)&jresult = new std::vector< std::string >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1url_1seeds(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< std::string > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_url_seeds(arg1,(std::vector< std::string > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1trackers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::string > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_trackers(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::string > **)&jresult = new std::vector< std::string >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1trackers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::string > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< std::string > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::string > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_trackers(arg1,(std::vector< std::string > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1merkle_1trees(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::vector< libtorrent::sha256_hash > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_merkle_trees(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< libtorrent::sha256_hash > > **)&jresult = new std::vector< std::vector< libtorrent::sha256_hash > >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1merkle_1trees(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::vector< libtorrent::sha256_hash > > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< std::vector< libtorrent::sha256_hash > > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::vector< libtorrent::sha256_hash > > & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_merkle_trees(arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1merkle_1tree_1mask(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< libtorrent::bitfield > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_merkle_tree_mask(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::bitfield > **)&jresult = new std::vector< libtorrent::bitfield >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1piece_1priorities2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_piece_priorities2(arg1,(std::vector< signed char > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1verified_1leaf_1hashes_1old(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::vector< bool > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = (std::vector< std::vector< bool > > *) &libtorrent_add_torrent_params_get_verified_leaf_hashes_old(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< bool > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1verified_1leaf_1hashes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< libtorrent::bitfield > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_verified_leaf_hashes(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::bitfield > **)&jresult = new std::vector< libtorrent::bitfield >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1unfinished_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::map< int,libtorrent::bitfield,std::less< int > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_unfinished_pieces(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,libtorrent::bitfield,std::less< int > > **)&jresult = new std::map< int,libtorrent::bitfield,std::less< int > >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1unfinished_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::map< int,libtorrent::bitfield,std::less< int > > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::map< int,libtorrent::bitfield,std::less< int > > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< int,libtorrent::bitfield,std::less< int > > & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_unfinished_pieces(arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1renamed_1files(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::map< int,std::string,std::less< int > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_renamed_files(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::map< int,std::string,std::less< int > > **)&jresult = new std::map< int,std::string,std::less< int > >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1have_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::bitfield result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_have_pieces(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bitfield **)&jresult = new libtorrent::bitfield(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1have_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::bitfield *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(libtorrent::bitfield **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bitfield & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_have_pieces(arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1get_1verified_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::bitfield result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      result = libtorrent_add_torrent_params_get_verified_pieces(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bitfield **)&jresult = new libtorrent::bitfield(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1verified_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::bitfield *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(libtorrent::bitfield **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bitfield & is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_verified_pieces(arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1create_1instance(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent_add_torrent_params_create_instance();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_params **)&jresult = new libtorrent::add_torrent_params(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1read_1resume_1data_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_add_torrent_params_read_resume_data__SWIG_0((libtorrent::bdecode_node const &)*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_params **)&jresult = new libtorrent::add_torrent_params(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1read_1resume_1data_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_add_torrent_params_read_resume_data__SWIG_1((std::vector< signed char > const &)*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_params **)&jresult = new libtorrent::add_torrent_params(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1write_1resume_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::entry result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::add_torrent_params const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_add_torrent_params_write_resume_data((libtorrent::add_torrent_params const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = new libtorrent::entry(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1write_1resume_1data_1buf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::add_torrent_params const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_add_torrent_params_write_resume_data_buf((libtorrent::add_torrent_params const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1parse_1magnet_1uri(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::string *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  std::string arg1_str(arg1_pstr);
  arg1 = &arg1_str;
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_add_torrent_params_parse_magnet_uri((std::string const &)*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_params **)&jresult = new libtorrent::add_torrent_params(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_close_1reason_1t_1none_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::close_reason_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::close_reason_t)libtorrent::close_reason_t::none;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_close_1reason_1t_1encryption_1error_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::close_reason_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::close_reason_t)libtorrent::close_reason_t::encryption_error;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1peer_1info_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::peer_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::peer_info *)new libtorrent::peer_info();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1info(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_info *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1peer_1info_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::peer_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::peer_info const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::peer_info *)new libtorrent::peer_info((libtorrent::peer_info const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1total_1download_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_download = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1total_1download_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_download);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1total_1upload_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_upload = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1total_1upload_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_upload);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1interesting_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::interesting;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1choked_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::choked;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1remote_1interested_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::remote_interested;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1remote_1choked_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::remote_choked;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1supports_1extensions_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::supports_extensions;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1outgoing_1connection_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::outgoing_connection;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1local_1connection_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::local_connection;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1handshake_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::handshake;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1connecting_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::connecting;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1on_1parole_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::on_parole;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1seed_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::seed;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1optimistic_1unchoke_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::optimistic_unchoke;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1snubbed_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::snubbed;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1upload_1only_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::upload_only;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1endgame_1mode_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::endgame_mode;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1holepunched_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::holepunched;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1i2p_1socket_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::i2p_socket;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1utp_1socket_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::utp_socket;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1ssl_1socket_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::ssl_socket;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1rc4_1encrypted_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::rc4_encrypted;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1plaintext_1encrypted_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > *)&libtorrent::peer_info::plaintext_encrypted;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::peer_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1flags_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::peer_flags_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = *(libtorrent::peer_flags_t **)&jarg2; 
  if (arg1) (arg1)->flags = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1flags_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::peer_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (libtorrent::peer_flags_t *)& ((arg1)->flags);
  *(libtorrent::peer_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1tracker_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *)&libtorrent::peer_info::tracker;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1dht_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *)&libtorrent::peer_info::dht;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1pex_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *)&libtorrent::peer_info::pex;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1lsd_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *)&libtorrent::peer_info::lsd;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1resume_1data_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *)&libtorrent::peer_info::resume_data;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1incoming_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > *)&libtorrent::peer_info::incoming;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::peer_source_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1source_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::peer_source_flags_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = *(libtorrent::peer_source_flags_t **)&jarg2; 
  if (arg1) (arg1)->source = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1source_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::peer_source_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (libtorrent::peer_source_flags_t *)& ((arg1)->source);
  *(libtorrent::peer_source_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1up_1speed_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->up_speed = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1up_1speed_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->up_speed);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1down_1speed_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->down_speed = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1down_1speed_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->down_speed);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1payload_1up_1speed_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->payload_up_speed = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1payload_1up_1speed_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->payload_up_speed);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1payload_1down_1speed_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->payload_down_speed = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1payload_1down_1speed_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->payload_down_speed);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1pid_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::peer_id *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = *(libtorrent::peer_id **)&jarg2; 
  if (arg1) (arg1)->pid = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1pid_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::peer_id *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (libtorrent::peer_id *)& ((arg1)->pid);
  *(libtorrent::peer_id **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1queue_1bytes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->queue_bytes = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1queue_1bytes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->queue_bytes);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1request_1timeout_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->request_timeout = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1request_1timeout_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->request_timeout);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1send_1buffer_1size_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->send_buffer_size = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1send_1buffer_1size_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->send_buffer_size);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1used_1send_1buffer_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->used_send_buffer = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1used_1send_1buffer_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->used_send_buffer);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1receive_1buffer_1size_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->receive_buffer_size = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1receive_1buffer_1size_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->receive_buffer_size);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1used_1receive_1buffer_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->used_receive_buffer = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1used_1receive_1buffer_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->used_receive_buffer);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1receive_1buffer_1watermark_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->receive_buffer_watermark = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1receive_1buffer_1watermark_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->receive_buffer_watermark);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1num_1hashfails_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_hashfails = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1num_1hashfails_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->num_hashfails);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1download_1queue_1length_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->download_queue_length = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1download_1queue_1length_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->download_queue_length);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1timed_1out_1requests_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->timed_out_requests = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1timed_1out_1requests_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->timed_out_requests);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1busy_1requests_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->busy_requests = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1busy_1requests_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->busy_requests);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1requests_1in_1buffer_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->requests_in_buffer = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1requests_1in_1buffer_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->requests_in_buffer);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1target_1dl_1queue_1length_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->target_dl_queue_length = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1target_1dl_1queue_1length_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->target_dl_queue_length);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1upload_1queue_1length_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->upload_queue_length = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1upload_1queue_1length_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->upload_queue_length);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1failcount_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->failcount = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1failcount_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->failcount);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1downloading_1piece_1index_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  piece_index_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  if (arg1) (arg1)->downloading_piece_index = arg2;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1downloading_1piece_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result =  ((arg1)->downloading_piece_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1downloading_1block_1index_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->downloading_block_index = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1downloading_1block_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->downloading_block_index);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1downloading_1progress_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->downloading_progress = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1downloading_1progress_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->downloading_progress);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1downloading_1total_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->downloading_total = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1downloading_1total_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->downloading_total);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1standard_1bittorrent_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::connection_type_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::connection_type_tag > *)&libtorrent::peer_info::standard_bittorrent;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::connection_type_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1web_1seed_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::connection_type_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::connection_type_tag > *)&libtorrent::peer_info::web_seed;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::connection_type_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1http_1seed_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::connection_type_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::connection_type_tag > *)&libtorrent::peer_info::http_seed;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::connection_type_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1connection_1type_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::connection_type_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = *(libtorrent::connection_type_t **)&jarg2; 
  if (arg1) (arg1)->connection_type = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1connection_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::connection_type_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (libtorrent::connection_type_t *)& ((arg1)->connection_type);
  *(libtorrent::connection_type_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1pending_1disk_1bytes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->pending_disk_bytes = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1pending_1disk_1bytes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->pending_disk_bytes);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1pending_1disk_1read_1bytes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->pending_disk_read_bytes = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1pending_1disk_1read_1bytes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->pending_disk_read_bytes);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1send_1quota_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->send_quota = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1send_1quota_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->send_quota);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1receive_1quota_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->receive_quota = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1receive_1quota_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->receive_quota);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1rtt_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->rtt = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1rtt_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->rtt);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1num_1pieces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_pieces = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1num_1pieces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->num_pieces);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1download_1rate_1peak_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->download_rate_peak = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1download_1rate_1peak_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->download_rate_peak);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1upload_1rate_1peak_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->upload_rate_peak = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1upload_1rate_1peak_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->upload_rate_peak);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1progress_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  float arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->progress = arg2;
}


SWIGEXPORT jfloat JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1progress_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jfloat jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  float result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (float) ((arg1)->progress);
  jresult = (jfloat)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1progress_1ppm_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->progress_ppm = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1progress_1ppm_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->progress_ppm);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1ip_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::tcp::endpoint *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = *(libtorrent::tcp::endpoint **)&jarg2; 
  if (arg1) (arg1)->ip = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1ip_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::tcp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (libtorrent::tcp::endpoint *)& ((arg1)->ip);
  *(libtorrent::tcp::endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1local_1endpoint_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::tcp::endpoint *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = *(libtorrent::tcp::endpoint **)&jarg2; 
  if (arg1) (arg1)->local_endpoint = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1local_1endpoint_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::tcp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (libtorrent::tcp::endpoint *)& ((arg1)->local_endpoint);
  *(libtorrent::tcp::endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1bw_1idle_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > *)&libtorrent::peer_info::bw_idle;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1bw_1limit_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > *)&libtorrent::peer_info::bw_limit;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1bw_1network_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > *)&libtorrent::peer_info::bw_network;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1bw_1disk_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > *)&libtorrent::peer_info::bw_disk;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::bandwidth_state_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1read_1state_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::bandwidth_state_flags_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = *(libtorrent::bandwidth_state_flags_t **)&jarg2; 
  if (arg1) (arg1)->read_state = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1read_1state_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::bandwidth_state_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (libtorrent::bandwidth_state_flags_t *)& ((arg1)->read_state);
  *(libtorrent::bandwidth_state_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1write_1state_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::bandwidth_state_flags_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = *(libtorrent::bandwidth_state_flags_t **)&jarg2; 
  if (arg1) (arg1)->write_state = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1write_1state_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::bandwidth_state_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (libtorrent::bandwidth_state_flags_t *)& ((arg1)->write_state);
  *(libtorrent::bandwidth_state_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1get_1client(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  {
    try {
      result = libtorrent_peer_info_get_client(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1get_1last_1request(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_peer_info_get_last_request(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1get_1last_1active(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_peer_info_get_last_active(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1get_1download_1queue_1time(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_peer_info_get_download_queue_time(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1get_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  std::int32_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  {
    try {
      result = (std::int32_t)libtorrent_peer_info_get_flags(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1get_1source(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jbyte jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  std::int8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  {
    try {
      result = (std::int8_t)libtorrent_peer_info_get_source(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1get_1read_1state(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jbyte jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  std::int8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  {
    try {
      result = (std::int8_t)libtorrent_peer_info_get_read_state(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1get_1write_1state(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jbyte jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  std::int8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  {
    try {
      result = (std::int8_t)libtorrent_peer_info_get_write_state(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jbyte)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1get_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = 0 ;
  libtorrent::bitfield result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  {
    try {
      result = libtorrent_peer_info_get_pieces(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bitfield **)&jresult = new libtorrent::bitfield(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1connection_1type_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1type_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1type_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1type_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1type_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1type_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1type_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1type_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1type_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1type_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1type_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1type_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_connection_type_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1connection_1type_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::connection_type_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1peer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::block_info *arg1 = 0 ;
  libtorrent::tcp::endpoint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_info **)&jarg1; 
  {
    try {
      result = ((libtorrent::block_info const *)arg1)->peer();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tcp::endpoint **)&jresult = new libtorrent::tcp::endpoint(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1bytes_1progress_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::block_info *arg1 = 0 ;
  unsigned int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_info **)&jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->bytes_progress = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1bytes_1progress_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::block_info *arg1 = 0 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_info **)&jarg1; 
  result = (unsigned int) ((arg1)->bytes_progress);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1block_1size_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::block_info *arg1 = 0 ;
  unsigned int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_info **)&jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->block_size = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1block_1size_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::block_info *arg1 = 0 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_info **)&jarg1; 
  result = (unsigned int) ((arg1)->block_size);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1state_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::block_info *arg1 = 0 ;
  unsigned int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_info **)&jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->state = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1state_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::block_info *arg1 = 0 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_info **)&jarg1; 
  result = (unsigned int) ((arg1)->state);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1num_1peers_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::block_info *arg1 = 0 ;
  unsigned int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_info **)&jarg1; 
  arg2 = (unsigned int)jarg2; 
  if (arg1) (arg1)->num_peers = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1num_1peers_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::block_info *arg1 = 0 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_info **)&jarg1; 
  result = (unsigned int) ((arg1)->num_peers);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1block_1info(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::block_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::block_info *)new libtorrent::block_info();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::block_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1block_1info(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::block_info *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::block_info **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1piece_1index_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::partial_piece_info *arg1 = 0 ;
  piece_index_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::partial_piece_info **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  if (arg1) (arg1)->piece_index = arg2;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1piece_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::partial_piece_info *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::partial_piece_info **)&jarg1; 
  result =  ((arg1)->piece_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1blocks_1in_1piece_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::partial_piece_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::partial_piece_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->blocks_in_piece = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1blocks_1in_1piece_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::partial_piece_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::partial_piece_info **)&jarg1; 
  result = (int) ((arg1)->blocks_in_piece);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1finished_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::partial_piece_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::partial_piece_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->finished = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1finished_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::partial_piece_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::partial_piece_info **)&jarg1; 
  result = (int) ((arg1)->finished);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1writing_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::partial_piece_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::partial_piece_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->writing = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1writing_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::partial_piece_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::partial_piece_info **)&jarg1; 
  result = (int) ((arg1)->writing);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1requested_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::partial_piece_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::partial_piece_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->requested = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1requested_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::partial_piece_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::partial_piece_info **)&jarg1; 
  result = (int) ((arg1)->requested);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1partial_1piece_1info(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::partial_piece_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::partial_piece_info *)new libtorrent::partial_piece_info();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::partial_piece_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1partial_1piece_1info(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::partial_piece_info *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::partial_piece_info **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1overwrite_1existing_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::add_piece_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::add_piece_flags_tag > *)&libtorrent::torrent_handle::overwrite_existing;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::add_piece_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1read_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  piece_index_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->read_piece(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1have_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jboolean jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  piece_index_t arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (bool)((libtorrent::torrent_handle const *)arg1)->have_piece(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1post_1peer_1info(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->post_peer_info();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1get_1peer_1info(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< libtorrent::peer_info > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(std::vector< libtorrent::peer_info > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::peer_info > & is null");
    return ;
  } 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->get_peer_info(*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1query_1distributed_1copies_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *)&libtorrent::torrent_handle::query_distributed_copies;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1query_1accurate_1download_1counters_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *)&libtorrent::torrent_handle::query_accurate_download_counters;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1query_1last_1seen_1complete_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *)&libtorrent::torrent_handle::query_last_seen_complete;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1query_1pieces_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *)&libtorrent::torrent_handle::query_pieces;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1query_1verified_1pieces_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *)&libtorrent::torrent_handle::query_verified_pieces;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1query_1torrent_1file_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *)&libtorrent::torrent_handle::query_torrent_file;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1query_1name_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *)&libtorrent::torrent_handle::query_name;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1query_1save_1path_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > *)&libtorrent::torrent_handle::query_save_path;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::status_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1status_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::status_flags_t arg2 ;
  libtorrent::status_flags_t *argp2 ;
  libtorrent::torrent_status result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  argp2 = *(libtorrent::status_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::status_flags_t");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->status(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_status **)&jresult = new libtorrent::torrent_status(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1status_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::torrent_status result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->status();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_status **)&jresult = new libtorrent::torrent_status(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1post_1status_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::status_flags_t arg2 ;
  libtorrent::status_flags_t *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  argp2 = *(libtorrent::status_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::status_flags_t");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->post_status(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1post_1status_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->post_status();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1post_1download_1queue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->post_download_queue();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1get_1download_1queue_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< libtorrent::partial_piece_info > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->get_download_queue();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::partial_piece_info > **)&jresult = new std::vector< libtorrent::partial_piece_info >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1get_1download_1queue_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(std::vector< libtorrent::partial_piece_info > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::partial_piece_info > & is null");
    return ;
  } 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->get_download_queue(*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1alert_1when_1available_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::deadline_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::deadline_flags_tag > *)&libtorrent::torrent_handle::alert_when_available;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::deadline_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1set_1piece_1deadline_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jint jarg3, jlong jarg4, jobject jarg4_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  piece_index_t arg2 ;
  int arg3 ;
  libtorrent::deadline_flags_t arg4 ;
  libtorrent::deadline_flags_t *argp4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg4_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = (int)jarg3; 
  argp4 = *(libtorrent::deadline_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::deadline_flags_t");
    return ;
  }
  arg4 = *argp4; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->set_piece_deadline(SWIG_STD_MOVE(arg2),arg3,SWIG_STD_MOVE(arg4));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1set_1piece_1deadline_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jint jarg3) {
  libtorrent::torrent_handle *arg1 = 0 ;
  piece_index_t arg2 ;
  int arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = (int)jarg3; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->set_piece_deadline(SWIG_STD_MOVE(arg2),arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1reset_1piece_1deadline(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  piece_index_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->reset_piece_deadline(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1clear_1piece_1deadlines(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->clear_piece_deadlines();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1piece_1granularity_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_progress_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_progress_flags_tag > *)&libtorrent::torrent_handle::piece_granularity;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::file_progress_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1file_1progress_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< std::int64_t > *arg2 = 0 ;
  libtorrent::file_progress_flags_t arg3 ;
  libtorrent::file_progress_flags_t *argp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(std::vector< std::int64_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int64_t > & is null");
    return ;
  } 
  argp3 = *(libtorrent::file_progress_flags_t **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::file_progress_flags_t");
    return ;
  }
  arg3 = *argp3; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->file_progress(*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1file_1progress_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< std::int64_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(std::vector< std::int64_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int64_t > & is null");
    return ;
  } 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->file_progress(*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1file_1progress_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::file_progress_flags_t arg2 ;
  libtorrent::file_progress_flags_t *argp2 ;
  std::vector< std::int64_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  argp2 = *(libtorrent::file_progress_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::file_progress_flags_t");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->file_progress(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int64_t > **)&jresult = new std::vector< std::int64_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1file_1progress_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< std::int64_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->file_progress();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int64_t > **)&jresult = new std::vector< std::int64_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1post_1file_1progress(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::file_progress_flags_t arg2 ;
  libtorrent::file_progress_flags_t *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  argp2 = *(libtorrent::file_progress_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::file_progress_flags_t");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->post_file_progress(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1clear_1error(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->clear_error();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1trackers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< libtorrent::announce_entry > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->trackers();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::announce_entry > **)&jresult = new std::vector< libtorrent::announce_entry >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1replace_1trackers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< libtorrent::announce_entry > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(std::vector< libtorrent::announce_entry > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::announce_entry > const & is null");
    return ;
  } 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->replace_trackers((std::vector< libtorrent::announce_entry > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1add_1tracker(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::announce_entry *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(libtorrent::announce_entry **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::announce_entry const & is null");
    return ;
  } 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->add_tracker((libtorrent::announce_entry const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1post_1trackers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->post_trackers();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1add_1url_1seed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->add_url_seed((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1remove_1url_1seed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->remove_url_seed((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1add_1http_1seed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->add_http_seed((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1remove_1http_1seed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->remove_http_seed((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1is_1valid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::torrent_handle const *)arg1)->is_valid();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1graceful_1pause_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::pause_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::pause_flags_tag > *)&libtorrent::torrent_handle::graceful_pause;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::pause_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1pause_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::pause_flags_t arg2 ;
  libtorrent::pause_flags_t *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  argp2 = *(libtorrent::pause_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::pause_flags_t");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->pause(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1pause_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->pause();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1resume(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->resume();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::torrent_flags_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->flags();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_flags_t **)&jresult = new libtorrent::torrent_flags_t(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1set_1flags_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::torrent_flags_t arg2 ;
  libtorrent::torrent_flags_t arg3 ;
  libtorrent::torrent_flags_t *argp2 ;
  libtorrent::torrent_flags_t *argp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  argp2 = *(libtorrent::torrent_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::torrent_flags_t");
    return ;
  }
  arg2 = *argp2; 
  argp3 = *(libtorrent::torrent_flags_t **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::torrent_flags_t");
    return ;
  }
  arg3 = *argp3; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->set_flags(SWIG_STD_MOVE(arg2),SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1set_1flags_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::torrent_flags_t arg2 ;
  libtorrent::torrent_flags_t *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  argp2 = *(libtorrent::torrent_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::torrent_flags_t");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->set_flags(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1unset_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::torrent_flags_t arg2 ;
  libtorrent::torrent_flags_t *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  argp2 = *(libtorrent::torrent_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::torrent_flags_t");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->unset_flags(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1flush_1cache(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->flush_cache();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1force_1recheck(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->force_recheck();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1flush_1disk_1cache_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *)&libtorrent::torrent_handle::flush_disk_cache;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1save_1info_1dict_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *)&libtorrent::torrent_handle::save_info_dict;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1only_1if_1modified_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *)&libtorrent::torrent_handle::only_if_modified;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1if_1counters_1changed_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *)&libtorrent::torrent_handle::if_counters_changed;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1if_1download_1progress_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *)&libtorrent::torrent_handle::if_download_progress;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1if_1config_1changed_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *)&libtorrent::torrent_handle::if_config_changed;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1if_1state_1changed_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *)&libtorrent::torrent_handle::if_state_changed;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1if_1metadata_1changed_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > *)&libtorrent::torrent_handle::if_metadata_changed;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::resume_data_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1save_1resume_1data_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::resume_data_flags_t arg2 ;
  libtorrent::resume_data_flags_t *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  argp2 = *(libtorrent::resume_data_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::resume_data_flags_t");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->save_resume_data(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1save_1resume_1data_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->save_resume_data();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1get_1resume_1data_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::resume_data_flags_t arg2 ;
  libtorrent::resume_data_flags_t *argp2 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  argp2 = *(libtorrent::resume_data_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::resume_data_flags_t");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->get_resume_data(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_params **)&jresult = new libtorrent::add_torrent_params(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1get_1resume_1data_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->get_resume_data();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_params **)&jresult = new libtorrent::add_torrent_params(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1need_1save_1resume_1data_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::torrent_handle const *)arg1)->need_save_resume_data();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1need_1save_1resume_1data_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::resume_data_flags_t arg2 ;
  libtorrent::resume_data_flags_t *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  argp2 = *(libtorrent::resume_data_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::resume_data_flags_t");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)((libtorrent::torrent_handle const *)arg1)->need_save_resume_data(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1queue_1position_1up(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->queue_position_up();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1queue_1position_1down(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->queue_position_down();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1queue_1position_1top(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->queue_position_top();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1queue_1position_1bottom(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->queue_position_bottom();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1set_1ssl_1certificate_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4, jstring jarg5) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  std::string *arg5 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  if(!jarg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg4_pstr = jenv->GetStringUTFChars(jarg4, 0); 
  if (!arg4_pstr) return ;
  std::string arg4_str(arg4_pstr);
  arg4 = &arg4_str;
  jenv->ReleaseStringUTFChars(jarg4, arg4_pstr); 
  if(!jarg5) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg5_pstr = jenv->GetStringUTFChars(jarg5, 0); 
  if (!arg5_pstr) return ;
  std::string arg5_str(arg5_pstr);
  arg5 = &arg5_str;
  jenv->ReleaseStringUTFChars(jarg5, arg5_pstr); 
  {
    try {
      (arg1)->set_ssl_certificate((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4,(std::string const &)*arg5);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1set_1ssl_1certificate_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3, jstring jarg4) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  std::string *arg4 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  if(!jarg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg4_pstr = jenv->GetStringUTFChars(jarg4, 0); 
  if (!arg4_pstr) return ;
  std::string arg4_str(arg4_pstr);
  arg4 = &arg4_str;
  jenv->ReleaseStringUTFChars(jarg4, arg4_pstr); 
  {
    try {
      (arg1)->set_ssl_certificate((std::string const &)*arg2,(std::string const &)*arg3,(std::string const &)*arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1torrent_1file_1with_1hashes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  SwigValueWrapper< std::shared_ptr< libtorrent::torrent_info > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->torrent_file_with_hashes();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::shared_ptr< libtorrent::torrent_info > **)&jresult = new std::shared_ptr< libtorrent::torrent_info >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1piece_1layers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< std::vector< libtorrent::sha256_hash > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->piece_layers();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::vector< libtorrent::sha256_hash > > **)&jresult = new std::vector< std::vector< libtorrent::sha256_hash > >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1post_1piece_1availability(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->post_piece_availability();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1piece_1availability(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< int > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(std::vector< int > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > & is null");
    return ;
  } 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->piece_availability(*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1ignore_1min_1interval_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::reannounce_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::reannounce_flags_tag > *)&libtorrent::torrent_handle::ignore_min_interval;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::reannounce_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1force_1reannounce_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jlong jarg4, jobject jarg4_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  libtorrent::reannounce_flags_t arg4 ;
  libtorrent::reannounce_flags_t *argp4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg4_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  argp4 = *(libtorrent::reannounce_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::reannounce_flags_t");
    return ;
  }
  arg4 = *argp4; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->force_reannounce(arg2,arg3,SWIG_STD_MOVE(arg4));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1force_1reannounce_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  libtorrent::torrent_handle *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->force_reannounce(arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1force_1reannounce_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->force_reannounce(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1force_1reannounce_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->force_reannounce();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1force_1dht_1announce(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->force_dht_announce();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1force_1lsd_1announce(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->force_lsd_announce();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1scrape_1tracker_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->scrape_tracker(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1scrape_1tracker_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->scrape_tracker();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1set_1upload_1limit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->set_upload_limit(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1upload_1limit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_handle const *)arg1)->upload_limit();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1set_1download_1limit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->set_download_limit(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1download_1limit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_handle const *)arg1)->download_limit();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1connect_1peer_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4) {
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::tcp::endpoint *arg2 = 0 ;
  libtorrent::peer_source_flags_t arg3 ;
  pex_flags_t arg4 ;
  libtorrent::peer_source_flags_t *argp3 ;
  pex_flags_t *argp4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(libtorrent::tcp::endpoint **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::tcp::endpoint const & is null");
    return ;
  } 
  argp3 = *(libtorrent::peer_source_flags_t **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::peer_source_flags_t");
    return ;
  }
  arg3 = *argp3; 
  argp4 = *(pex_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null pex_flags_t");
    return ;
  }
  arg4 = *argp4; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->connect_peer((libtorrent::tcp::endpoint const &)*arg2,SWIG_STD_MOVE(arg3),SWIG_STD_MOVE(arg4));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1connect_1peer_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::tcp::endpoint *arg2 = 0 ;
  libtorrent::peer_source_flags_t arg3 ;
  libtorrent::peer_source_flags_t *argp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(libtorrent::tcp::endpoint **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::tcp::endpoint const & is null");
    return ;
  } 
  argp3 = *(libtorrent::peer_source_flags_t **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::peer_source_flags_t");
    return ;
  }
  arg3 = *argp3; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->connect_peer((libtorrent::tcp::endpoint const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1connect_1peer_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::tcp::endpoint *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(libtorrent::tcp::endpoint **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::tcp::endpoint const & is null");
    return ;
  } 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->connect_peer((libtorrent::tcp::endpoint const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1clear_1peers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      (arg1)->clear_peers();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1set_1max_1uploads(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->set_max_uploads(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1max_1uploads(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_handle const *)arg1)->max_uploads();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1set_1max_1connections(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->set_max_connections(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1max_1connections(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_handle const *)arg1)->max_connections();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1move_1storage_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::string *arg2 = 0 ;
  libtorrent::move_flags_t arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = (libtorrent::move_flags_t)jarg3; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->move_storage((std::string const &)*arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1move_1storage_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->move_storage((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1rename_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jstring jarg3) {
  libtorrent::torrent_handle *arg1 = 0 ;
  file_index_t arg2 ;
  std::string *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->rename_file(SWIG_STD_MOVE(arg2),(std::string const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1info_1hash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::sha1_hash result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->info_hash();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::sha1_hash **)&jresult = new libtorrent::sha1_hash(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1info_1hashes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::info_hash_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->info_hashes();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::info_hash_t **)&jresult = new libtorrent::info_hash_t(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1op_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::torrent_handle *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(libtorrent::torrent_handle **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_handle const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::torrent_handle const *)arg1)->operator ==((libtorrent::torrent_handle const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1op_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::torrent_handle *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(libtorrent::torrent_handle **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_handle const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::torrent_handle const *)arg1)->operator !=((libtorrent::torrent_handle const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1op_1lt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::torrent_handle *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(libtorrent::torrent_handle **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_handle const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::torrent_handle const *)arg1)->operator <((libtorrent::torrent_handle const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  std::uint32_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = (std::uint32_t)((libtorrent::torrent_handle const *)arg1)->id();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1userdata(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::client_data_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_handle const *)arg1)->userdata();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::client_data_t **)&jresult = new libtorrent::client_data_t(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1in_1session(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::torrent_handle const *)arg1)->in_session();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1add_1piece_1bytes_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  int arg2 ;
  std::vector< int8_t > *arg3 = 0 ;
  libtorrent::add_piece_flags_t arg4 ;
  libtorrent::add_piece_flags_t *argp4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  (void)jarg4_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return ;
  } 
  argp4 = *(libtorrent::add_piece_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::add_piece_flags_t");
    return ;
  }
  arg4 = *argp4; 
  {
    try {
      libtorrent_torrent_handle_add_piece_bytes__SWIG_0(arg1,arg2,(std::vector< signed char > const &)*arg3,SWIG_STD_MOVE(arg4));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1add_1piece_1bytes_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  int arg2 ;
  std::vector< int8_t > *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_torrent_handle_add_piece_bytes__SWIG_0(arg1,arg2,(std::vector< signed char > const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1torrent_1file_1ptr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::torrent_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_info *)libtorrent_torrent_handle_torrent_file_ptr(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1torrent_1file_1with_1hashes_1ptr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  libtorrent::torrent_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_info *)libtorrent_torrent_handle_torrent_file_with_hashes_ptr(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1get_1url_1seeds(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< std::string > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = libtorrent_torrent_handle_get_url_seeds((libtorrent::torrent_handle const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::string > **)&jresult = new std::vector< std::string >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1get_1http_1seeds(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< std::string > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = libtorrent_torrent_handle_get_http_seeds((libtorrent::torrent_handle const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::string > **)&jresult = new std::vector< std::string >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1set_1ssl_1certificate_1buffer2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  std::vector< int8_t > *arg3 = 0 ;
  std::vector< int8_t > *arg4 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  (void)jarg4_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return ;
  } 
  arg3 = *(std::vector< int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return ;
  } 
  arg4 = *(std::vector< int8_t > **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_torrent_handle_set_ssl_certificate_buffer2(arg1,(std::vector< signed char > const &)*arg2,(std::vector< signed char > const &)*arg3,(std::vector< signed char > const &)*arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1queue_1position2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = (int)libtorrent_torrent_handle_queue_position2((libtorrent::torrent_handle const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1queue_1position_1set2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      libtorrent_torrent_handle_queue_position_set2(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1piece_1priority2_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jint jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  piece_index_t arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (int)libtorrent_torrent_handle_piece_priority2__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1piece_1priority2_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jint jarg3) {
  libtorrent::torrent_handle *arg1 = 0 ;
  piece_index_t arg2 ;
  int arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = (int)jarg3; 
  {
    try {
      libtorrent_torrent_handle_piece_priority2__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1prioritize_1pieces2_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< int > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(std::vector< int > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_torrent_handle_prioritize_pieces2__SWIG_0(arg1,(std::vector< int > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1prioritize_1pieces2_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< std::pair< piece_index_t,int > > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(std::vector< std::pair< piece_index_t,int > > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< piece_index_t,int > > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_torrent_handle_prioritize_pieces2__SWIG_1(arg1,(std::vector< std::pair< piece_index_t,int > > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1get_1piece_1priorities2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< int > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = libtorrent_torrent_handle_get_piece_priorities2((libtorrent::torrent_handle const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int > **)&jresult = new std::vector< int >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1file_1priority2_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jint jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  file_index_t arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (int)libtorrent_torrent_handle_file_priority2__SWIG_0(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1file_1priority2_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jint jarg3) {
  libtorrent::torrent_handle *arg1 = 0 ;
  file_index_t arg2 ;
  int arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = (int)jarg3; 
  {
    try {
      libtorrent_torrent_handle_file_priority2__SWIG_1(arg1,SWIG_STD_MOVE(arg2),arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1prioritize_1files2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< int > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(std::vector< int > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_torrent_handle_prioritize_files2(arg1,(std::vector< int > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1get_1file_1priorities2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  std::vector< int > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      result = libtorrent_torrent_handle_get_file_priorities2((libtorrent::torrent_handle const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int > **)&jresult = new std::vector< int >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1handle(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1add_1piece_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1piece_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1piece_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1piece_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1piece_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1piece_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1piece_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1piece_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1piece_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1piece_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1piece_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1piece_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_add_piece_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1add_1piece_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1deadline_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_deadline_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_deadline_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_deadline_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_deadline_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_deadline_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_deadline_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_deadline_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_deadline_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_deadline_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_deadline_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_deadline_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_deadline_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1deadline_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1file_1progress_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_file_progress_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1progress_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_progress_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1pause_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pause_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pause_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pause_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pause_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pause_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pause_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pause_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pause_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pause_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pause_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pause_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_pause_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1pause_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1resume_1data_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_resume_1data_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_resume_1data_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_resume_1data_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_resume_1data_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_resume_1data_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_resume_1data_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_resume_1data_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_resume_1data_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_resume_1data_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_resume_1data_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_resume_1data_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_resume_data_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1resume_1data_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1reannounce_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reannounce_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reannounce_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reannounce_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reannounce_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reannounce_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reannounce_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reannounce_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reannounce_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reannounce_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reannounce_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reannounce_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reannounce_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1reannounce_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1status_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_status_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1status_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1status_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::torrent_status *)new libtorrent::torrent_status();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_status **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1status(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_status *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1torrent_1status_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::torrent_status *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_status const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::torrent_status *)new libtorrent::torrent_status((libtorrent::torrent_status const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_status **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1op_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::torrent_status *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = *(libtorrent::torrent_status **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_status const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::torrent_status const *)arg1)->operator ==((libtorrent::torrent_status const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1handle_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::torrent_handle *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = *(libtorrent::torrent_handle **)&jarg2; 
  if (arg1) (arg1)->handle = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1handle_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::torrent_handle *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (libtorrent::torrent_handle *)& ((arg1)->handle);
  *(libtorrent::torrent_handle **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1checking_1files_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::torrent_status::state_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_status::state_t)libtorrent::torrent_status::checking_files;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1downloading_1metadata_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::torrent_status::state_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_status::state_t)libtorrent::torrent_status::downloading_metadata;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1downloading_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::torrent_status::state_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_status::state_t)libtorrent::torrent_status::downloading;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1finished_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::torrent_status::state_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_status::state_t)libtorrent::torrent_status::finished;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1seeding_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::torrent_status::state_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_status::state_t)libtorrent::torrent_status::seeding;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1checking_1resume_1data_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::torrent_status::state_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_status::state_t)libtorrent::torrent_status::checking_resume_data;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1errc_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2; 
  if (arg1) (arg1)->errc = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1errc_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->errc);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1error_1file_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  file_index_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  if (arg1) (arg1)->error_file = arg2;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1error_1file_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result =  ((arg1)->error_file);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1error_1file_1none_1get(JNIEnv *jenv, jclass jcls) {
  int jresult = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  result = libtorrent::torrent_status::error_file_none;
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1error_1file_1ssl_1ctx_1get(JNIEnv *jenv, jclass jcls) {
  int jresult = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  result = libtorrent::torrent_status::error_file_ssl_ctx;
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1error_1file_1metadata_1get(JNIEnv *jenv, jclass jcls) {
  int jresult = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  result = libtorrent::torrent_status::error_file_metadata;
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1error_1file_1exception_1get(JNIEnv *jenv, jclass jcls) {
  int jresult = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  result = libtorrent::torrent_status::error_file_exception;
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1error_1file_1partfile_1get(JNIEnv *jenv, jclass jcls) {
  int jresult = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  result = libtorrent::torrent_status::error_file_partfile;
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1save_1path_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->save_path = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1save_1path_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::string *) & ((arg1)->save_path);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1name_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->name = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1name_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::string *) & ((arg1)->name);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1current_1tracker_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->current_tracker = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1current_1tracker_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::string *) & ((arg1)->current_tracker);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1download_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_download = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1download_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_download);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1upload_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_upload = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1upload_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_upload);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1payload_1download_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_payload_download = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1payload_1download_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_payload_download);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1payload_1upload_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_payload_upload = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1payload_1upload_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_payload_upload);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1failed_1bytes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_failed_bytes = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1failed_1bytes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_failed_bytes);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1redundant_1bytes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_redundant_bytes = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1redundant_1bytes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_redundant_bytes);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1done_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_done = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1done_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_done);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->total);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1wanted_1done_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_wanted_done = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1wanted_1done_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_wanted_done);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1wanted_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->total_wanted = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1total_1wanted_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->total_wanted);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1all_1time_1upload_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->all_time_upload = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1all_1time_1upload_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->all_time_upload);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1all_1time_1download_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  if (arg1) (arg1)->all_time_download = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1all_1time_1download_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (std::int64_t) ((arg1)->all_time_download);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1added_1time_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::time_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::time_t)jarg2; 
  if (arg1) (arg1)->added_time = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1added_1time_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::time_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result =  ((arg1)->added_time);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1completed_1time_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::time_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::time_t)jarg2; 
  if (arg1) (arg1)->completed_time = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1completed_1time_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::time_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result =  ((arg1)->completed_time);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1last_1seen_1complete_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  std::time_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (std::time_t)jarg2; 
  if (arg1) (arg1)->last_seen_complete = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1last_1seen_1complete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  std::time_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result =  ((arg1)->last_seen_complete);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1storage_1mode_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::storage_mode_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (libtorrent::storage_mode_t)jarg2; 
  if (arg1) (arg1)->storage_mode = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1storage_1mode_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::storage_mode_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (libtorrent::storage_mode_t) ((arg1)->storage_mode);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1progress_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  float arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->progress = arg2;
}


SWIGEXPORT jfloat JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1progress_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jfloat jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  float result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (float) ((arg1)->progress);
  jresult = (jfloat)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1progress_1ppm_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->progress_ppm = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1progress_1ppm_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->progress_ppm);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1download_1rate_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->download_rate = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1download_1rate_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->download_rate);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1upload_1rate_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->upload_rate = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1upload_1rate_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->upload_rate);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1download_1payload_1rate_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->download_payload_rate = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1download_1payload_1rate_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->download_payload_rate);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1upload_1payload_1rate_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->upload_payload_rate = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1upload_1payload_1rate_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->upload_payload_rate);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1seeds_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_seeds = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1seeds_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->num_seeds);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1peers_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_peers = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1peers_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->num_peers);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1complete_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_complete = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1complete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->num_complete);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1incomplete_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_incomplete = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1incomplete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->num_incomplete);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1list_1seeds_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->list_seeds = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1list_1seeds_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->list_seeds);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1list_1peers_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->list_peers = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1list_1peers_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->list_peers);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1connect_1candidates_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->connect_candidates = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1connect_1candidates_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->connect_candidates);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1pieces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_pieces = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1pieces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->num_pieces);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1distributed_1full_1copies_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->distributed_full_copies = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1distributed_1full_1copies_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->distributed_full_copies);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1distributed_1fraction_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->distributed_fraction = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1distributed_1fraction_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->distributed_fraction);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1distributed_1copies_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jfloat jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  float arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (float)jarg2; 
  if (arg1) (arg1)->distributed_copies = arg2;
}


SWIGEXPORT jfloat JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1distributed_1copies_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jfloat jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  float result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (float) ((arg1)->distributed_copies);
  jresult = (jfloat)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1block_1size_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->block_size = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1block_1size_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->block_size);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1uploads_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_uploads = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1uploads_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->num_uploads);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1connections_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_connections = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1num_1connections_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->num_connections);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1uploads_1limit_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->uploads_limit = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1uploads_1limit_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->uploads_limit);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1connections_1limit_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->connections_limit = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1connections_1limit_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->connections_limit);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1up_1bandwidth_1queue_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->up_bandwidth_queue = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1up_1bandwidth_1queue_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->up_bandwidth_queue);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1down_1bandwidth_1queue_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->down_bandwidth_queue = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1down_1bandwidth_1queue_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->down_bandwidth_queue);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1seed_1rank_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->seed_rank = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1seed_1rank_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (int) ((arg1)->seed_rank);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1state_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::torrent_status::state_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = (libtorrent::torrent_status::state_t)jarg2; 
  if (arg1) (arg1)->state = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1state_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::torrent_status::state_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (libtorrent::torrent_status::state_t) ((arg1)->state);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1need_1save_1resume_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->need_save_resume = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1need_1save_1resume_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (bool) ((arg1)->need_save_resume);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1is_1seeding_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->is_seeding = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1is_1seeding_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (bool) ((arg1)->is_seeding);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1is_1finished_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->is_finished = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1is_1finished_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (bool) ((arg1)->is_finished);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1has_1metadata_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->has_metadata = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1has_1metadata_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (bool) ((arg1)->has_metadata);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1has_1incoming_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->has_incoming = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1has_1incoming_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (bool) ((arg1)->has_incoming);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1moving_1storage_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->moving_storage = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1moving_1storage_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (bool) ((arg1)->moving_storage);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1announcing_1to_1trackers_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->announcing_to_trackers = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1announcing_1to_1trackers_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (bool) ((arg1)->announcing_to_trackers);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1announcing_1to_1lsd_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->announcing_to_lsd = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1announcing_1to_1lsd_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (bool) ((arg1)->announcing_to_lsd);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1announcing_1to_1dht_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::torrent_status *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->announcing_to_dht = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1announcing_1to_1dht_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (bool) ((arg1)->announcing_to_dht);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1info_1hashes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::info_hash_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = *(libtorrent::info_hash_t **)&jarg2; 
  if (arg1) (arg1)->info_hashes = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1info_1hashes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::info_hash_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (libtorrent::info_hash_t *)& ((arg1)->info_hashes);
  *(libtorrent::info_hash_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1flags_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::torrent_flags_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = *(libtorrent::torrent_flags_t **)&jarg2; 
  if (arg1) (arg1)->flags = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1flags_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (libtorrent::torrent_flags_t *)& ((arg1)->flags);
  *(libtorrent::torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1torrent_1file_1ptr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::torrent_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_info *)libtorrent_torrent_status_torrent_file_ptr(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1get_1next_1announce(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_torrent_status_get_next_announce(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1get_1last_1upload(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_torrent_status_get_last_upload(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1get_1last_1download(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_torrent_status_get_last_download(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1get_1active_1duration(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_torrent_status_get_active_duration(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1get_1finished_1duration(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_torrent_status_get_finished_duration(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1get_1seeding_1duration(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_torrent_status_get_seeding_duration(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1get_1queue_1position(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    try {
      result = (int)libtorrent_torrent_status_get_queue_position(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1get_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::bitfield result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    try {
      result = libtorrent_torrent_status_get_pieces(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bitfield **)&jresult = new libtorrent::bitfield(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1get_1verified_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = 0 ;
  libtorrent::bitfield result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  {
    try {
      result = libtorrent_torrent_status_get_verified_pieces(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bitfield **)&jresult = new libtorrent::bitfield(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_counters_1num_1checking_1torrents_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::counters::stats_gauge_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::counters::stats_gauge_t)libtorrent::counters::num_checking_torrents;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_counters_1num_1gauges_1counters_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::counters::stats_gauge_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::counters::stats_gauge_t)libtorrent::counters::num_gauges_counters;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1counters_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::counters *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::counters *)new libtorrent::counters();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::counters **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1counters_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::counters *arg1 = 0 ;
  libtorrent::counters *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::counters **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::counters const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::counters *)new libtorrent::counters((libtorrent::counters const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::counters **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_counters_1inc_1stats_1counter_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  libtorrent::counters *arg1 = 0 ;
  int arg2 ;
  std::int64_t arg3 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::counters **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::int64_t)jarg3; 
  {
    try {
      result = (std::int64_t)(arg1)->inc_stats_counter(arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_counters_1inc_1stats_1counter_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::counters *arg1 = 0 ;
  int arg2 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::counters **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (std::int64_t)(arg1)->inc_stats_counter(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_counters_1op_1at(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::counters *arg1 = 0 ;
  int arg2 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::counters **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (std::int64_t)((libtorrent::counters const *)arg1)->operator [](arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_counters_1set_1value(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  libtorrent::counters *arg1 = 0 ;
  int arg2 ;
  std::int64_t arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::counters **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::int64_t)jarg3; 
  {
    try {
      (arg1)->set_value(arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_counters_1blend_1stats_1counter(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jint jarg4) {
  libtorrent::counters *arg1 = 0 ;
  int arg2 ;
  std::int64_t arg3 ;
  int arg4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::counters **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (std::int64_t)jarg3; 
  arg4 = (int)jarg4; 
  {
    try {
      (arg1)->blend_stats_counter(arg2,arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1counters(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::counters *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::counters **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1invalid_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::piece_block *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::piece_block *)&libtorrent::piece_block::invalid;
  *(libtorrent::piece_block **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1block_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::piece_block *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::piece_block *)new libtorrent::piece_block();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::piece_block **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1block_1_1SWIG_11(JNIEnv *jenv, jclass jcls, int jarg1, jint jarg2) {
  jlong jresult = 0 ;
  piece_index_t arg1 ;
  int arg2 ;
  libtorrent::piece_block *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    arg1 = piece_index_t(static_cast<std::int32_t>(jarg1));
  }
  arg2 = (int)jarg2; 
  {
    try {
      result = (libtorrent::piece_block *)new libtorrent::piece_block(SWIG_STD_MOVE(arg1),arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::piece_block **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1piece_1index_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::piece_block *arg1 = 0 ;
  piece_index_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_block **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  if (arg1) (arg1)->piece_index = arg2;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1piece_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::piece_block *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_block **)&jarg1; 
  result =  ((arg1)->piece_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1block_1index_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::piece_block *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_block **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->block_index = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1block_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::piece_block *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_block **)&jarg1; 
  result = (int) ((arg1)->block_index);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1op_1lt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::piece_block *arg1 = 0 ;
  libtorrent::piece_block *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::piece_block **)&jarg1; 
  arg2 = *(libtorrent::piece_block **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::piece_block const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::piece_block const *)arg1)->operator <((libtorrent::piece_block const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1op_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::piece_block *arg1 = 0 ;
  libtorrent::piece_block *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::piece_block **)&jarg1; 
  arg2 = *(libtorrent::piece_block **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::piece_block const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::piece_block const *)arg1)->operator ==((libtorrent::piece_block const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1block_1op_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::piece_block *arg1 = 0 ;
  libtorrent::piece_block *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::piece_block **)&jarg1; 
  arg2 = *(libtorrent::piece_block **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::piece_block const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::piece_block const *)arg1)->operator !=((libtorrent::piece_block const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1piece_1block(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::piece_block *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::piece_block **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::entry *arg1 = 0 ;
  libtorrent::entry::data_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  {
    try {
      result = (libtorrent::entry::data_type)((libtorrent::entry const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1entry_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::entry::dictionary_type arg1 ;
  libtorrent::entry::dictionary_type *argp1 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(libtorrent::entry::dictionary_type **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::entry::dictionary_type");
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (libtorrent::entry *)new libtorrent::entry(SWIG_STD_MOVE(arg1));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1entry_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1) {
  jlong jresult = 0 ;
  libtorrent::entry::string_type arg1 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  {
    try {
      result = (libtorrent::entry *)new libtorrent::entry(SWIG_STD_MOVE(arg1));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1entry_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::entry::list_type arg1 ;
  libtorrent::entry::list_type *argp1 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(libtorrent::entry::list_type **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::entry::list_type");
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (libtorrent::entry *)new libtorrent::entry(SWIG_STD_MOVE(arg1));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1entry_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  jlong jresult = 0 ;
  libtorrent::entry::integer_type arg1 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (libtorrent::entry::integer_type)jarg1; 
  {
    try {
      result = (libtorrent::entry *)new libtorrent::entry(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1entry_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  libtorrent::entry::data_type arg1 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (libtorrent::entry::data_type)jarg1; 
  {
    try {
      result = (libtorrent::entry *)new libtorrent::entry(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1entry_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::entry *arg1 = 0 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::entry *)new libtorrent::entry((libtorrent::entry const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1entry_1_1SWIG_16(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::entry *)new libtorrent::entry();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1integer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::entry *arg1 = 0 ;
  libtorrent::entry::integer_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  {
    try {
      result = (libtorrent::entry::integer_type *) &((libtorrent::entry const *)arg1)->integer();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)*result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1string(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::entry *arg1 = 0 ;
  libtorrent::entry::string_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  {
    try {
      result = (libtorrent::entry::string_type *) &((libtorrent::entry const *)arg1)->string();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1list(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::entry *arg1 = 0 ;
  libtorrent::entry::list_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  {
    try {
      result = (libtorrent::entry::list_type *) &(arg1)->list();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry::list_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1dict(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::entry *arg1 = 0 ;
  libtorrent::entry::dictionary_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  {
    try {
      result = (libtorrent::entry::dictionary_type *) &(arg1)->dict();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry::dictionary_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1to_1string(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::entry *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  {
    try {
      result = ((libtorrent::entry const *)arg1)->to_string();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  libtorrent::entry *arg1 = 0 ;
  std::string *arg2 = 0 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (libtorrent::entry *) &libtorrent_entry_get(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1set_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
  libtorrent::entry *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::string *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  std::string arg3_str(arg3_pstr);
  arg3 = &arg3_str;
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      libtorrent_entry_set__SWIG_0(arg1,(std::string const &)*arg2,(std::string const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1set_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  libtorrent::entry *arg1 = 0 ;
  std::string *arg2 = 0 ;
  std::vector< int8_t > *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(std::vector< int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_entry_set__SWIG_1(arg1,(std::string const &)*arg2,(std::vector< signed char > const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1set_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3) {
  libtorrent::entry *arg1 = 0 ;
  std::string *arg2 = 0 ;
  long long *arg3 = 0 ;
  long long temp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  temp3 = (long long)jarg3; 
  arg3 = &temp3; 
  {
    try {
      libtorrent_entry_set__SWIG_2(arg1,(std::string const &)*arg2,(long long const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1set_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  libtorrent::entry *arg1 = 0 ;
  std::string *arg2 = 0 ;
  libtorrent::entry *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(libtorrent::entry **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry const & is null");
    return ;
  } 
  {
    try {
      libtorrent_entry_set__SWIG_3(arg1,(std::string const &)*arg2,(libtorrent::entry const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1string_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::entry *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  {
    try {
      result = libtorrent_entry_string_bytes(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1preformatted_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::entry *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  {
    try {
      result = libtorrent_entry_preformatted_bytes(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1bencode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::entry *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  {
    try {
      result = libtorrent_entry_bencode(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1from_1string_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  libtorrent::entry result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_entry_from_string_bytes((std::vector< signed char > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = new libtorrent::entry(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1from_1preformatted_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  libtorrent::entry result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_entry_from_preformatted_bytes((std::vector< signed char > const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = new libtorrent::entry(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1bdecode(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  libtorrent::entry result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_entry_bdecode(*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = new libtorrent::entry(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1entry(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::entry *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::entry **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_error_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::error;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::peer;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_port_1mapping_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::port_mapping;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::storage;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::tracker;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connect_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::connect;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_status_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::status;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1block_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::ip_block;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1warning_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::performance_warning;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::dht;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::stats;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1log_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::session_log;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1log_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::torrent_log;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::peer_log;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1request_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::incoming_request;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::dht_log;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1operation_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::dht_operation;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_port_1mapping_1log_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::port_mapping_log;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::picker_log;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::file_progress;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1progress_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::piece_progress;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_upload_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::upload;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1progress_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::alert_category_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::alert_category_t *)&libtorrent::alert_category::block_progress;
  *(libtorrent::alert_category_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1error_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::error_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1peer_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::peer_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1port_1mapping_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::port_mapping_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1storage_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::storage_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1tracker_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::tracker_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1connect_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::connect_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1status_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::status_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ip_1block_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::ip_block_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1performance_1warning_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::performance_warning;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1dht_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::dht_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1session_1log_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::session_log_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1torrent_1log_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::torrent_log_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1peer_1log_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::peer_log_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1incoming_1request_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::incoming_request_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1dht_1log_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::dht_log_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1dht_1operation_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::dht_operation_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1port_1mapping_1log_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::port_mapping_log_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1picker_1log_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::picker_log_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1file_1progress_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::file_progress_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1piece_1progress_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::piece_progress_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1upload_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::upload_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1block_1progress_1notification_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::block_progress_notification;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1all_1categories_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alert::all_categories;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1get_1timestamp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_alert_get_timestamp(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1add_1torrent_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::add_torrent_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::add_torrent_alert *)libtorrent_alert_cast_to_add_torrent_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1alerts_1dropped_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::alerts_dropped_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::alerts_dropped_alert *)libtorrent_alert_cast_to_alerts_dropped_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alerts_dropped_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1block_1downloading_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::block_downloading_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::block_downloading_alert *)libtorrent_alert_cast_to_block_downloading_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::block_downloading_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1block_1finished_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::block_finished_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::block_finished_alert *)libtorrent_alert_cast_to_block_finished_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::block_finished_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1block_1timeout_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::block_timeout_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::block_timeout_alert *)libtorrent_alert_cast_to_block_timeout_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::block_timeout_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1block_1uploaded_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::block_uploaded_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::block_uploaded_alert *)libtorrent_alert_cast_to_block_uploaded_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::block_uploaded_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1cache_1flushed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::cache_flushed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::cache_flushed_alert *)libtorrent_alert_cast_to_cache_flushed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::cache_flushed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1announce_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_announce_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_announce_alert *)libtorrent_alert_cast_to_dht_announce_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_announce_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1bootstrap_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_bootstrap_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_bootstrap_alert *)libtorrent_alert_cast_to_dht_bootstrap_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_bootstrap_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1direct_1response_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_direct_response_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_direct_response_alert *)libtorrent_alert_cast_to_dht_direct_response_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_direct_response_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_error_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_error_alert *)libtorrent_alert_cast_to_dht_error_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_error_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1get_1peers_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_get_peers_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_get_peers_alert *)libtorrent_alert_cast_to_dht_get_peers_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_get_peers_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1get_1peers_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_get_peers_reply_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_get_peers_reply_alert *)libtorrent_alert_cast_to_dht_get_peers_reply_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_get_peers_reply_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1immutable_1item_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_immutable_item_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_immutable_item_alert *)libtorrent_alert_cast_to_dht_immutable_item_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_immutable_item_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1live_1nodes_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_live_nodes_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_live_nodes_alert *)libtorrent_alert_cast_to_dht_live_nodes_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_live_nodes_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_log_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_log_alert *)libtorrent_alert_cast_to_dht_log_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_log_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1mutable_1item_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_mutable_item_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_mutable_item_alert *)libtorrent_alert_cast_to_dht_mutable_item_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_mutable_item_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1outgoing_1get_1peers_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_outgoing_get_peers_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_outgoing_get_peers_alert *)libtorrent_alert_cast_to_dht_outgoing_get_peers_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_outgoing_get_peers_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1pkt_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_pkt_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_pkt_alert *)libtorrent_alert_cast_to_dht_pkt_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_pkt_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1put_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_put_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_put_alert *)libtorrent_alert_cast_to_dht_put_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_put_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_reply_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_reply_alert *)libtorrent_alert_cast_to_dht_reply_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_reply_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1sample_1infohashes_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_sample_infohashes_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_sample_infohashes_alert *)libtorrent_alert_cast_to_dht_sample_infohashes_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_sample_infohashes_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1dht_1stats_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::dht_stats_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::dht_stats_alert *)libtorrent_alert_cast_to_dht_stats_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_stats_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1external_1ip_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::external_ip_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::external_ip_alert *)libtorrent_alert_cast_to_external_ip_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::external_ip_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1fastresume_1rejected_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::fastresume_rejected_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::fastresume_rejected_alert *)libtorrent_alert_cast_to_fastresume_rejected_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::fastresume_rejected_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1file_1completed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::file_completed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::file_completed_alert *)libtorrent_alert_cast_to_file_completed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_completed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1file_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::file_error_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::file_error_alert *)libtorrent_alert_cast_to_file_error_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_error_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1file_1prio_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::file_prio_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::file_prio_alert *)libtorrent_alert_cast_to_file_prio_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_prio_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1file_1progress_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::file_progress_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::file_progress_alert *)libtorrent_alert_cast_to_file_progress_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_progress_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1file_1rename_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::file_rename_failed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::file_rename_failed_alert *)libtorrent_alert_cast_to_file_rename_failed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_rename_failed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1file_1renamed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::file_renamed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::file_renamed_alert *)libtorrent_alert_cast_to_file_renamed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_renamed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1hash_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::hash_failed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::hash_failed_alert *)libtorrent_alert_cast_to_hash_failed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::hash_failed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1i2p_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::i2p_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::i2p_alert *)libtorrent_alert_cast_to_i2p_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::i2p_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1incoming_1connection_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::incoming_connection_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::incoming_connection_alert *)libtorrent_alert_cast_to_incoming_connection_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::incoming_connection_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1incoming_1request_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::incoming_request_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::incoming_request_alert *)libtorrent_alert_cast_to_incoming_request_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::incoming_request_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1invalid_1request_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::invalid_request_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::invalid_request_alert *)libtorrent_alert_cast_to_invalid_request_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::invalid_request_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1listen_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::listen_failed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::listen_failed_alert *)libtorrent_alert_cast_to_listen_failed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::listen_failed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1listen_1succeeded_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::listen_succeeded_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::listen_succeeded_alert *)libtorrent_alert_cast_to_listen_succeeded_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::listen_succeeded_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::log_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::log_alert *)libtorrent_alert_cast_to_log_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::log_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1lsd_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::lsd_error_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::lsd_error_alert *)libtorrent_alert_cast_to_lsd_error_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::lsd_error_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1lsd_1peer_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::lsd_peer_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::lsd_peer_alert *)libtorrent_alert_cast_to_lsd_peer_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::lsd_peer_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1metadata_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::metadata_failed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::metadata_failed_alert *)libtorrent_alert_cast_to_metadata_failed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::metadata_failed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1metadata_1received_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::metadata_received_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::metadata_received_alert *)libtorrent_alert_cast_to_metadata_received_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::metadata_received_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1oversized_1file_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::oversized_file_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::oversized_file_alert *)libtorrent_alert_cast_to_oversized_file_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::oversized_file_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1peer_1ban_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::peer_ban_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::peer_ban_alert *)libtorrent_alert_cast_to_peer_ban_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_ban_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1peer_1blocked_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::peer_blocked_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::peer_blocked_alert *)libtorrent_alert_cast_to_peer_blocked_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_blocked_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1peer_1connect_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::peer_connect_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::peer_connect_alert *)libtorrent_alert_cast_to_peer_connect_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_connect_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1peer_1disconnected_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::peer_disconnected_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::peer_disconnected_alert *)libtorrent_alert_cast_to_peer_disconnected_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_disconnected_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1peer_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::peer_error_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::peer_error_alert *)libtorrent_alert_cast_to_peer_error_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_error_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1peer_1info_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::peer_info_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::peer_info_alert *)libtorrent_alert_cast_to_peer_info_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_info_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1peer_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::peer_log_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::peer_log_alert *)libtorrent_alert_cast_to_peer_log_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_log_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1peer_1snubbed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::peer_snubbed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::peer_snubbed_alert *)libtorrent_alert_cast_to_peer_snubbed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_snubbed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1peer_1unsnubbed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::peer_unsnubbed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::peer_unsnubbed_alert *)libtorrent_alert_cast_to_peer_unsnubbed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_unsnubbed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1performance_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::performance_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::performance_alert *)libtorrent_alert_cast_to_performance_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::performance_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1picker_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::picker_log_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::picker_log_alert *)libtorrent_alert_cast_to_picker_log_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::picker_log_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1piece_1availability_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::piece_availability_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::piece_availability_alert *)libtorrent_alert_cast_to_piece_availability_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::piece_availability_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1piece_1finished_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::piece_finished_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::piece_finished_alert *)libtorrent_alert_cast_to_piece_finished_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::piece_finished_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1piece_1info_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::piece_info_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::piece_info_alert *)libtorrent_alert_cast_to_piece_info_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::piece_info_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1portmap_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::portmap_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::portmap_alert *)libtorrent_alert_cast_to_portmap_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::portmap_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1portmap_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::portmap_error_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::portmap_error_alert *)libtorrent_alert_cast_to_portmap_error_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::portmap_error_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1portmap_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::portmap_log_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::portmap_log_alert *)libtorrent_alert_cast_to_portmap_log_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::portmap_log_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1read_1piece_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::read_piece_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::read_piece_alert *)libtorrent_alert_cast_to_read_piece_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::read_piece_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1request_1dropped_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::request_dropped_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::request_dropped_alert *)libtorrent_alert_cast_to_request_dropped_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::request_dropped_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1save_1resume_1data_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::save_resume_data_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::save_resume_data_alert *)libtorrent_alert_cast_to_save_resume_data_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::save_resume_data_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1save_1resume_1data_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::save_resume_data_failed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::save_resume_data_failed_alert *)libtorrent_alert_cast_to_save_resume_data_failed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::save_resume_data_failed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1scrape_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::scrape_failed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::scrape_failed_alert *)libtorrent_alert_cast_to_scrape_failed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::scrape_failed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1scrape_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::scrape_reply_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::scrape_reply_alert *)libtorrent_alert_cast_to_scrape_reply_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::scrape_reply_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1session_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::session_error_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::session_error_alert *)libtorrent_alert_cast_to_session_error_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_error_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1session_1stats_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::session_stats_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::session_stats_alert *)libtorrent_alert_cast_to_session_stats_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_stats_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1session_1stats_1header_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::session_stats_header_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::session_stats_header_alert *)libtorrent_alert_cast_to_session_stats_header_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_stats_header_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1socks5_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::socks5_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::socks5_alert *)libtorrent_alert_cast_to_socks5_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::socks5_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1state_1changed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::state_changed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::state_changed_alert *)libtorrent_alert_cast_to_state_changed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::state_changed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1state_1update_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::state_update_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::state_update_alert *)libtorrent_alert_cast_to_state_update_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::state_update_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1storage_1moved_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::storage_moved_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::storage_moved_alert *)libtorrent_alert_cast_to_storage_moved_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::storage_moved_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1storage_1moved_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::storage_moved_failed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::storage_moved_failed_alert *)libtorrent_alert_cast_to_storage_moved_failed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::storage_moved_failed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1torrent_1checked_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::torrent_checked_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_checked_alert *)libtorrent_alert_cast_to_torrent_checked_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_checked_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1torrent_1conflict_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::torrent_conflict_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_conflict_alert *)libtorrent_alert_cast_to_torrent_conflict_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_conflict_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1torrent_1delete_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::torrent_delete_failed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_delete_failed_alert *)libtorrent_alert_cast_to_torrent_delete_failed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_delete_failed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1torrent_1deleted_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::torrent_deleted_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_deleted_alert *)libtorrent_alert_cast_to_torrent_deleted_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_deleted_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1torrent_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::torrent_error_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_error_alert *)libtorrent_alert_cast_to_torrent_error_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_error_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1torrent_1finished_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::torrent_finished_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_finished_alert *)libtorrent_alert_cast_to_torrent_finished_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_finished_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1torrent_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::torrent_log_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_log_alert *)libtorrent_alert_cast_to_torrent_log_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_log_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1torrent_1need_1cert_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::torrent_need_cert_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_need_cert_alert *)libtorrent_alert_cast_to_torrent_need_cert_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_need_cert_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1torrent_1paused_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::torrent_paused_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_paused_alert *)libtorrent_alert_cast_to_torrent_paused_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_paused_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1torrent_1removed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::torrent_removed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_removed_alert *)libtorrent_alert_cast_to_torrent_removed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_removed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1torrent_1resumed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::torrent_resumed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::torrent_resumed_alert *)libtorrent_alert_cast_to_torrent_resumed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_resumed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1tracker_1announce_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::tracker_announce_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::tracker_announce_alert *)libtorrent_alert_cast_to_tracker_announce_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tracker_announce_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1tracker_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::tracker_error_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::tracker_error_alert *)libtorrent_alert_cast_to_tracker_error_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tracker_error_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1tracker_1list_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::tracker_list_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::tracker_list_alert *)libtorrent_alert_cast_to_tracker_list_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tracker_list_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1tracker_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::tracker_reply_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::tracker_reply_alert *)libtorrent_alert_cast_to_tracker_reply_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tracker_reply_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1tracker_1warning_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::tracker_warning_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::tracker_warning_alert *)libtorrent_alert_cast_to_tracker_warning_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tracker_warning_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1trackerid_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::trackerid_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::trackerid_alert *)libtorrent_alert_cast_to_trackerid_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::trackerid_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1udp_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::udp_error_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::udp_error_alert *)libtorrent_alert_cast_to_udp_error_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::udp_error_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1unwanted_1block_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::unwanted_block_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::unwanted_block_alert *)libtorrent_alert_cast_to_unwanted_block_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::unwanted_block_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1cast_1to_1url_1seed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = 0 ;
  libtorrent::url_seed_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::url_seed_alert *)libtorrent_alert_cast_to_url_seed_alert((libtorrent::alert const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::url_seed_alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1name(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jstring jresult = 0 ;
  int arg1 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = (char *)libtorrent::alert_name(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_num_1alert_1types_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::num_alert_types;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_abi_1alert_1count_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::abi_alert_count;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1priority_1normal_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::alert_priority)libtorrent::alert_priority::normal;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1num_1nodes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_routing_bucket *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_routing_bucket **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_nodes = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1num_1nodes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_routing_bucket *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_routing_bucket **)&jarg1; 
  result = (int) ((arg1)->num_nodes);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1num_1replacements_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_routing_bucket *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_routing_bucket **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_replacements = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1num_1replacements_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_routing_bucket *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_routing_bucket **)&jarg1; 
  result = (int) ((arg1)->num_replacements);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1last_1active_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_routing_bucket *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_routing_bucket **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->last_active = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1last_1active_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_routing_bucket *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_routing_bucket **)&jarg1; 
  result = (int) ((arg1)->last_active);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1dht_1routing_1bucket(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::dht_routing_bucket *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::dht_routing_bucket *)new libtorrent::dht_routing_bucket();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_routing_bucket **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1routing_1bucket(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_routing_bucket *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_routing_bucket **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1alert_1handle_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_alert *arg1 = 0 ;
  libtorrent::torrent_handle *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_alert **)&jarg1; 
  arg2 = *(libtorrent::torrent_handle **)&jarg2; 
  if (arg1) (arg1)->handle = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1alert_1handle_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_alert *arg1 = 0 ;
  libtorrent::torrent_handle *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_alert **)&jarg1; 
  result = (libtorrent::torrent_handle *)& ((arg1)->handle);
  *(libtorrent::torrent_handle **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1alert_1torrent_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_alert const *)arg1)->torrent_name();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1alert_1pid_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_alert *arg1 = 0 ;
  libtorrent::peer_id *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_alert **)&jarg1; 
  arg2 = *(libtorrent::peer_id **)&jarg2; 
  if (arg1) (arg1)->pid = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1alert_1pid_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_alert *arg1 = 0 ;
  libtorrent::peer_id *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_alert **)&jarg1; 
  result = (libtorrent::peer_id *)& ((arg1)->pid);
  *(libtorrent::peer_id **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1alert_1get_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_alert *arg1 = 0 ;
  libtorrent::tcp::endpoint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_alert **)&jarg1; 
  {
    try {
      result = libtorrent_peer_alert_get_endpoint(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tcp::endpoint **)&jresult = new libtorrent::tcp::endpoint(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::tracker_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1alert_1tracker_1url(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::tracker_alert const *)arg1)->tracker_url();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1alert_1get_1local_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::tracker_alert *arg1 = 0 ;
  libtorrent::tcp::endpoint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_alert **)&jarg1; 
  {
    try {
      result = libtorrent_tracker_alert_get_local_endpoint(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tcp::endpoint **)&jresult = new libtorrent::tcp::endpoint(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1tracker_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::tracker_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::tracker_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::torrent_removed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::torrent_removed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_removed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_removed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_removed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_removed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_removed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_removed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_removed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_removed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_removed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::torrent_removed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_removed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_removed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_removed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1info_1hashes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_removed_alert *arg1 = 0 ;
  libtorrent::info_hash_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_removed_alert **)&jarg1; 
  arg2 = *(libtorrent::info_hash_t **)&jarg2; 
  if (arg1) (arg1)->info_hashes = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1info_1hashes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_removed_alert *arg1 = 0 ;
  libtorrent::info_hash_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_removed_alert **)&jarg1; 
  result = (libtorrent::info_hash_t *)& ((arg1)->info_hashes);
  *(libtorrent::info_hash_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1userdata_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_removed_alert *arg1 = 0 ;
  libtorrent::client_data_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_removed_alert **)&jarg1; 
  arg2 = *(libtorrent::client_data_t **)&jarg2; 
  if (arg1) (arg1)->userdata = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1userdata_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_removed_alert *arg1 = 0 ;
  libtorrent::client_data_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_removed_alert **)&jarg1; 
  result = (libtorrent::client_data_t *)& ((arg1)->userdata);
  *(libtorrent::client_data_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1removed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_removed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_removed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::read_piece_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::read_piece_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::read_piece_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::read_piece_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::read_piece_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::read_piece_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::read_piece_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::read_piece_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::read_piece_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::read_piece_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::read_piece_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::read_piece_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::read_piece_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::read_piece_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::read_piece_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::read_piece_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::read_piece_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1piece_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::read_piece_alert *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::read_piece_alert **)&jarg1; 
  result = (piece_index_t) ((arg1)->piece);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1size_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::read_piece_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::read_piece_alert **)&jarg1; 
  result = (int)(int) ((arg1)->size);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1buffer_1ptr(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::read_piece_alert *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::read_piece_alert **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_read_piece_alert_buffer_ptr(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1read_1piece_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::read_piece_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::read_piece_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1completed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::file_completed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1completed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::file_completed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1completed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_completed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_completed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::file_completed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1completed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_completed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_completed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_completed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1completed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_completed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_completed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::file_completed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1completed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::file_completed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1completed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_completed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_completed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_completed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1completed_1alert_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::file_completed_alert *arg1 = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_completed_alert **)&jarg1; 
  result = (file_index_t) ((arg1)->index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1completed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::file_completed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::file_completed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1renamed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::file_renamed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1renamed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::file_renamed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1renamed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_renamed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_renamed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::file_renamed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1renamed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_renamed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_renamed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_renamed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1renamed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_renamed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_renamed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::file_renamed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1renamed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::file_renamed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1renamed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_renamed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_renamed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_renamed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1renamed_1alert_1new_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_renamed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_renamed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::file_renamed_alert const *)arg1)->new_name();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1renamed_1alert_1old_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_renamed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_renamed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::file_renamed_alert const *)arg1)->old_name();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1renamed_1alert_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::file_renamed_alert *arg1 = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_renamed_alert **)&jarg1; 
  result = (file_index_t) ((arg1)->index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1renamed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::file_renamed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::file_renamed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1rename_1failed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::file_rename_failed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1rename_1failed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::file_rename_failed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1rename_1failed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_rename_failed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_rename_failed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::file_rename_failed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1rename_1failed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_rename_failed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_rename_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_rename_failed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1rename_1failed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_rename_failed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_rename_failed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::file_rename_failed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1rename_1failed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::file_rename_failed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1rename_1failed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_rename_failed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_rename_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_rename_failed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1rename_1failed_1alert_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::file_rename_failed_alert *arg1 = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_rename_failed_alert **)&jarg1; 
  result = (file_index_t) ((arg1)->index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1rename_1failed_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_rename_failed_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_rename_failed_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1rename_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::file_rename_failed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::file_rename_failed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1alert_1too_1few_1outgoing_1ports_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::performance_alert::performance_warning_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::performance_alert::performance_warning_t)libtorrent::performance_alert::too_few_outgoing_ports;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::performance_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::performance_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::performance_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::performance_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::performance_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::performance_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::performance_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::performance_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::performance_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::performance_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::performance_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::performance_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::performance_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::performance_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::performance_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1alert_1warning_1code_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::performance_alert *arg1 = 0 ;
  libtorrent::performance_alert::performance_warning_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::performance_alert **)&jarg1; 
  result = (libtorrent::performance_alert::performance_warning_t)(libtorrent::performance_alert::performance_warning_t) ((arg1)->warning_code);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1performance_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::performance_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::performance_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1changed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::state_changed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1changed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::state_changed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1changed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::state_changed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::state_changed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::state_changed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1changed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::state_changed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::state_changed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::state_changed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1changed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::state_changed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::state_changed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::state_changed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1changed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::state_changed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1changed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::state_changed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::state_changed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::state_changed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1changed_1alert_1state_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::state_changed_alert *arg1 = 0 ;
  libtorrent::torrent_status::state_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::state_changed_alert **)&jarg1; 
  result = (libtorrent::torrent_status::state_t)(libtorrent::torrent_status::state_t) ((arg1)->state);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1changed_1alert_1prev_1state_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::state_changed_alert *arg1 = 0 ;
  libtorrent::torrent_status::state_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::state_changed_alert **)&jarg1; 
  result = (libtorrent::torrent_status::state_t)(libtorrent::torrent_status::state_t) ((arg1)->prev_state);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1state_1changed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::state_changed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::state_changed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::tracker_error_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::tracker_error_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_error_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::tracker_error_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::tracker_error_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::tracker_error_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::tracker_error_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::tracker_error_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_error_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::tracker_error_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1times_1in_1row_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_error_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  result = (int)(int) ((arg1)->times_in_row);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::tracker_error_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1op_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::tracker_error_alert *arg1 = 0 ;
  libtorrent::operation_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  arg2 = (libtorrent::operation_t)jarg2; 
  if (arg1) (arg1)->op = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1op_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_error_alert *arg1 = 0 ;
  libtorrent::operation_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  result = (libtorrent::operation_t) ((arg1)->op);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1failure_1reason(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::tracker_error_alert const *)arg1)->failure_reason();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1error_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::tracker_error_alert const *)arg1)->error_message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1version_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::tracker_error_alert *arg1 = 0 ;
  libtorrent::protocol_version arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  arg2 = (libtorrent::protocol_version)jarg2; 
  if (arg1) (arg1)->version = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1version_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_error_alert *arg1 = 0 ;
  libtorrent::protocol_version result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  result = (libtorrent::protocol_version) ((arg1)->version);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1tracker_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::tracker_error_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::tracker_error_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1warning_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::tracker_warning_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1warning_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::tracker_warning_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1warning_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_warning_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_warning_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::tracker_warning_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1warning_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::tracker_warning_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_warning_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::tracker_warning_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1warning_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_warning_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_warning_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::tracker_warning_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1warning_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::tracker_warning_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1warning_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_warning_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_warning_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::tracker_warning_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1warning_1alert_1warning_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_warning_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_warning_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::tracker_warning_alert const *)arg1)->warning_message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1warning_1alert_1version_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::tracker_warning_alert *arg1 = 0 ;
  libtorrent::protocol_version arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_warning_alert **)&jarg1; 
  arg2 = (libtorrent::protocol_version)jarg2; 
  if (arg1) (arg1)->version = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1warning_1alert_1version_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_warning_alert *arg1 = 0 ;
  libtorrent::protocol_version result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_warning_alert **)&jarg1; 
  result = (libtorrent::protocol_version) ((arg1)->version);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1tracker_1warning_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::tracker_warning_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::tracker_warning_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::scrape_reply_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::scrape_reply_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::scrape_reply_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_reply_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::scrape_reply_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::scrape_reply_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_reply_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::scrape_reply_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::scrape_reply_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_reply_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::scrape_reply_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::scrape_reply_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::scrape_reply_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_reply_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::scrape_reply_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1incomplete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::scrape_reply_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_reply_alert **)&jarg1; 
  result = (int)(int) ((arg1)->incomplete);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1complete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::scrape_reply_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_reply_alert **)&jarg1; 
  result = (int)(int) ((arg1)->complete);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1version_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::scrape_reply_alert *arg1 = 0 ;
  libtorrent::protocol_version arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_reply_alert **)&jarg1; 
  arg2 = (libtorrent::protocol_version)jarg2; 
  if (arg1) (arg1)->version = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1version_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::scrape_reply_alert *arg1 = 0 ;
  libtorrent::protocol_version result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_reply_alert **)&jarg1; 
  result = (libtorrent::protocol_version) ((arg1)->version);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1scrape_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::scrape_reply_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::scrape_reply_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::scrape_failed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::scrape_failed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::scrape_failed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_failed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::scrape_failed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::scrape_failed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::scrape_failed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::scrape_failed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_failed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::scrape_failed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::scrape_failed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::scrape_failed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::scrape_failed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::scrape_failed_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_failed_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1error_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::scrape_failed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_failed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::scrape_failed_alert const *)arg1)->error_message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1version_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::scrape_failed_alert *arg1 = 0 ;
  libtorrent::protocol_version arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_failed_alert **)&jarg1; 
  arg2 = (libtorrent::protocol_version)jarg2; 
  if (arg1) (arg1)->version = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1version_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::scrape_failed_alert *arg1 = 0 ;
  libtorrent::protocol_version result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::scrape_failed_alert **)&jarg1; 
  result = (libtorrent::protocol_version) ((arg1)->version);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1scrape_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::scrape_failed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::scrape_failed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1reply_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::tracker_reply_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1reply_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::tracker_reply_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1reply_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_reply_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_reply_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::tracker_reply_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1reply_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::tracker_reply_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_reply_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::tracker_reply_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1reply_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_reply_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_reply_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::tracker_reply_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1reply_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::tracker_reply_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1reply_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_reply_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_reply_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::tracker_reply_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1reply_1alert_1num_1peers_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_reply_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_reply_alert **)&jarg1; 
  result = (int)(int) ((arg1)->num_peers);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1reply_1alert_1version_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::tracker_reply_alert *arg1 = 0 ;
  libtorrent::protocol_version arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_reply_alert **)&jarg1; 
  arg2 = (libtorrent::protocol_version)jarg2; 
  if (arg1) (arg1)->version = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1reply_1alert_1version_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_reply_alert *arg1 = 0 ;
  libtorrent::protocol_version result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_reply_alert **)&jarg1; 
  result = (libtorrent::protocol_version) ((arg1)->version);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1tracker_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::tracker_reply_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::tracker_reply_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1reply_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_reply_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1reply_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_reply_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1reply_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_reply_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_reply_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_reply_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1reply_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_reply_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_reply_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_reply_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1reply_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_reply_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_reply_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_reply_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1reply_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_reply_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1reply_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_reply_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_reply_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_reply_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1reply_1alert_1num_1peers_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_reply_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_reply_alert **)&jarg1; 
  result = (int)(int) ((arg1)->num_peers);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_reply_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_reply_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1announce_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::tracker_announce_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1announce_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::tracker_announce_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1announce_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_announce_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_announce_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::tracker_announce_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1announce_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::tracker_announce_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_announce_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::tracker_announce_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1announce_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_announce_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_announce_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::tracker_announce_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1announce_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::tracker_announce_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1announce_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_announce_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_announce_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::tracker_announce_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1announce_1alert_1event_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_announce_alert *arg1 = 0 ;
  libtorrent::event_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_announce_alert **)&jarg1; 
  result = (libtorrent::event_t)(libtorrent::event_t) ((arg1)->event);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1announce_1alert_1version_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::tracker_announce_alert *arg1 = 0 ;
  libtorrent::protocol_version arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_announce_alert **)&jarg1; 
  arg2 = (libtorrent::protocol_version)jarg2; 
  if (arg1) (arg1)->version = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1announce_1alert_1version_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_announce_alert *arg1 = 0 ;
  libtorrent::protocol_version result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_announce_alert **)&jarg1; 
  result = (libtorrent::protocol_version) ((arg1)->version);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1tracker_1announce_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::tracker_announce_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::tracker_announce_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_hash_1failed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::hash_failed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_hash_1failed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::hash_failed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_hash_1failed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::hash_failed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::hash_failed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::hash_failed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_hash_1failed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::hash_failed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::hash_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::hash_failed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_hash_1failed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::hash_failed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::hash_failed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::hash_failed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_hash_1failed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::hash_failed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_hash_1failed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::hash_failed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::hash_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::hash_failed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_hash_1failed_1alert_1piece_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::hash_failed_alert *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::hash_failed_alert **)&jarg1; 
  result = (piece_index_t) ((arg1)->piece_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1hash_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::hash_failed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::hash_failed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1ban_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::peer_ban_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1ban_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::peer_ban_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1ban_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_ban_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_ban_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::peer_ban_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1ban_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_ban_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_ban_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_ban_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1ban_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_ban_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_ban_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::peer_ban_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1ban_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::peer_ban_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1ban_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_ban_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_ban_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_ban_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1ban_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_ban_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_ban_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1unsnubbed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::peer_unsnubbed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1unsnubbed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::peer_unsnubbed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1unsnubbed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_unsnubbed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_unsnubbed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::peer_unsnubbed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1unsnubbed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_unsnubbed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_unsnubbed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_unsnubbed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1unsnubbed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_unsnubbed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_unsnubbed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::peer_unsnubbed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1unsnubbed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::peer_unsnubbed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1unsnubbed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_unsnubbed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_unsnubbed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_unsnubbed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1unsnubbed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_unsnubbed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_unsnubbed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1snubbed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::peer_snubbed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1snubbed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::peer_snubbed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1snubbed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_snubbed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_snubbed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::peer_snubbed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1snubbed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_snubbed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_snubbed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_snubbed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1snubbed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_snubbed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_snubbed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::peer_snubbed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1snubbed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::peer_snubbed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1snubbed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_snubbed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_snubbed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_snubbed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1snubbed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_snubbed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_snubbed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1error_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::peer_error_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1error_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::peer_error_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1error_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_error_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_error_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::peer_error_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1error_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_error_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_error_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1error_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::peer_error_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1error_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::peer_error_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1error_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_error_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_error_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1error_1alert_1op_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_error_alert *arg1 = 0 ;
  libtorrent::operation_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_error_alert **)&jarg1; 
  arg2 = (libtorrent::operation_t)jarg2; 
  if (arg1) (arg1)->op = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1error_1alert_1op_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_error_alert *arg1 = 0 ;
  libtorrent::operation_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_error_alert **)&jarg1; 
  result = (libtorrent::operation_t) ((arg1)->op);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1error_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_error_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_error_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_error_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_error_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::peer_connect_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::peer_connect_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_connect_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connect_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::peer_connect_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_connect_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connect_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_connect_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_connect_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connect_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::peer_connect_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::peer_connect_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_connect_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connect_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_connect_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1direction_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_connect_alert *arg1 = 0 ;
  libtorrent::peer_connect_alert::direction_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connect_alert **)&jarg1; 
  arg2 = (libtorrent::peer_connect_alert::direction_t)jarg2; 
  if (arg1) (arg1)->direction = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1direction_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_connect_alert *arg1 = 0 ;
  libtorrent::peer_connect_alert::direction_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connect_alert **)&jarg1; 
  result = (libtorrent::peer_connect_alert::direction_t) ((arg1)->direction);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1socket_1type_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_connect_alert *arg1 = 0 ;
  libtorrent::socket_type_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connect_alert **)&jarg1; 
  arg2 = (libtorrent::socket_type_t)jarg2; 
  if (arg1) (arg1)->socket_type = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1socket_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_connect_alert *arg1 = 0 ;
  libtorrent::socket_type_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connect_alert **)&jarg1; 
  result = (libtorrent::socket_type_t) ((arg1)->socket_type);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1connect_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_connect_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_connect_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::peer_disconnected_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::peer_disconnected_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_disconnected_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_disconnected_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::peer_disconnected_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_disconnected_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_disconnected_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_disconnected_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_disconnected_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_disconnected_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::peer_disconnected_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::peer_disconnected_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_disconnected_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_disconnected_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_disconnected_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1socket_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_disconnected_alert *arg1 = 0 ;
  libtorrent::socket_type_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_disconnected_alert **)&jarg1; 
  result = (libtorrent::socket_type_t)(libtorrent::socket_type_t) ((arg1)->socket_type);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1op_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_disconnected_alert *arg1 = 0 ;
  libtorrent::operation_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_disconnected_alert **)&jarg1; 
  result = (libtorrent::operation_t)(libtorrent::operation_t) ((arg1)->op);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_disconnected_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_disconnected_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1reason_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_disconnected_alert *arg1 = 0 ;
  libtorrent::close_reason_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_disconnected_alert **)&jarg1; 
  result = (libtorrent::close_reason_t)(libtorrent::close_reason_t) ((arg1)->reason);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1disconnected_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_disconnected_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_disconnected_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::invalid_request_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::invalid_request_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::invalid_request_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::invalid_request_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::invalid_request_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::invalid_request_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::invalid_request_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::invalid_request_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::invalid_request_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::invalid_request_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::invalid_request_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::invalid_request_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::invalid_request_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::invalid_request_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::invalid_request_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1request_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::invalid_request_alert *arg1 = 0 ;
  libtorrent::peer_request *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::invalid_request_alert **)&jarg1; 
  result = (libtorrent::peer_request *)& ((arg1)->request);
  *(libtorrent::peer_request **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1we_1have_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::invalid_request_alert *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::invalid_request_alert **)&jarg1; 
  result = (bool)(bool) ((arg1)->we_have);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1peer_1interested_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::invalid_request_alert *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::invalid_request_alert **)&jarg1; 
  result = (bool)(bool) ((arg1)->peer_interested);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1withheld_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::invalid_request_alert *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::invalid_request_alert **)&jarg1; 
  result = (bool)(bool) ((arg1)->withheld);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1invalid_1request_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::invalid_request_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::invalid_request_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1finished_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::torrent_finished_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1finished_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::torrent_finished_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1finished_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_finished_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_finished_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_finished_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1finished_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_finished_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_finished_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_finished_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1finished_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_finished_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_finished_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_finished_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1finished_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::torrent_finished_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1finished_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_finished_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_finished_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_finished_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1finished_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_finished_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_finished_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1finished_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::piece_finished_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1finished_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::piece_finished_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1finished_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::piece_finished_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_finished_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::piece_finished_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1finished_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::piece_finished_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_finished_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::piece_finished_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1finished_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::piece_finished_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_finished_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::piece_finished_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1finished_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::piece_finished_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1finished_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::piece_finished_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_finished_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::piece_finished_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1finished_1alert_1piece_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::piece_finished_alert *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_finished_alert **)&jarg1; 
  result = (piece_index_t) ((arg1)->piece_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1piece_1finished_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::piece_finished_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::piece_finished_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_request_1dropped_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::request_dropped_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_request_1dropped_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::request_dropped_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_request_1dropped_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::request_dropped_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::request_dropped_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::request_dropped_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_request_1dropped_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::request_dropped_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::request_dropped_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::request_dropped_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_request_1dropped_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::request_dropped_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::request_dropped_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::request_dropped_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_request_1dropped_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::request_dropped_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_request_1dropped_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::request_dropped_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::request_dropped_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::request_dropped_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_request_1dropped_1alert_1block_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::request_dropped_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::request_dropped_alert **)&jarg1; 
  result = (int)(int) ((arg1)->block_index);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_request_1dropped_1alert_1piece_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::request_dropped_alert *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::request_dropped_alert **)&jarg1; 
  result = (piece_index_t) ((arg1)->piece_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1request_1dropped_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::request_dropped_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::request_dropped_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1timeout_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::block_timeout_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1timeout_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::block_timeout_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1timeout_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::block_timeout_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_timeout_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::block_timeout_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1timeout_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::block_timeout_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_timeout_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::block_timeout_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1timeout_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::block_timeout_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_timeout_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::block_timeout_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1timeout_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::block_timeout_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1timeout_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::block_timeout_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_timeout_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::block_timeout_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1timeout_1alert_1block_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::block_timeout_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_timeout_alert **)&jarg1; 
  result = (int)(int) ((arg1)->block_index);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1timeout_1alert_1piece_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::block_timeout_alert *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_timeout_alert **)&jarg1; 
  result = (piece_index_t) ((arg1)->piece_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1block_1timeout_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::block_timeout_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::block_timeout_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1finished_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::block_finished_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1finished_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::block_finished_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1finished_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::block_finished_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_finished_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::block_finished_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1finished_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::block_finished_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_finished_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::block_finished_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1finished_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::block_finished_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_finished_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::block_finished_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1finished_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::block_finished_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1finished_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::block_finished_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_finished_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::block_finished_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1finished_1alert_1block_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::block_finished_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_finished_alert **)&jarg1; 
  result = (int)(int) ((arg1)->block_index);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1finished_1alert_1piece_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::block_finished_alert *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_finished_alert **)&jarg1; 
  result = (piece_index_t) ((arg1)->piece_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1block_1finished_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::block_finished_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::block_finished_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1downloading_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::block_downloading_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1downloading_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::block_downloading_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1downloading_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::block_downloading_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_downloading_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::block_downloading_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1downloading_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::block_downloading_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_downloading_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::block_downloading_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1downloading_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::block_downloading_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_downloading_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::block_downloading_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1downloading_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::block_downloading_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1downloading_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::block_downloading_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_downloading_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::block_downloading_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1downloading_1alert_1block_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::block_downloading_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_downloading_alert **)&jarg1; 
  result = (int)(int) ((arg1)->block_index);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1downloading_1alert_1piece_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::block_downloading_alert *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_downloading_alert **)&jarg1; 
  result = (piece_index_t) ((arg1)->piece_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1block_1downloading_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::block_downloading_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::block_downloading_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_unwanted_1block_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::unwanted_block_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_unwanted_1block_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::unwanted_block_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_unwanted_1block_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::unwanted_block_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::unwanted_block_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::unwanted_block_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_unwanted_1block_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::unwanted_block_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::unwanted_block_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::unwanted_block_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_unwanted_1block_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::unwanted_block_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::unwanted_block_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::unwanted_block_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_unwanted_1block_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::unwanted_block_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_unwanted_1block_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::unwanted_block_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::unwanted_block_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::unwanted_block_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_unwanted_1block_1alert_1block_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::unwanted_block_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::unwanted_block_alert **)&jarg1; 
  result = (int)(int) ((arg1)->block_index);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_unwanted_1block_1alert_1piece_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::unwanted_block_alert *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::unwanted_block_alert **)&jarg1; 
  result = (piece_index_t) ((arg1)->piece_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1unwanted_1block_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::unwanted_block_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::unwanted_block_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::storage_moved_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::storage_moved_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::storage_moved_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::storage_moved_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::storage_moved_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::storage_moved_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::storage_moved_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::storage_moved_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::storage_moved_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::storage_moved_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::storage_moved_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1alert_1storage_1path(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::storage_moved_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::storage_moved_alert const *)arg1)->storage_path();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1alert_1old_1path(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::storage_moved_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::storage_moved_alert const *)arg1)->old_path();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1storage_1moved_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::storage_moved_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::storage_moved_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::storage_moved_failed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::storage_moved_failed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::storage_moved_failed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_failed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::storage_moved_failed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::storage_moved_failed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::storage_moved_failed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::storage_moved_failed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_failed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::storage_moved_failed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::storage_moved_failed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::storage_moved_failed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::storage_moved_failed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::storage_moved_failed_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_failed_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1file_1path(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::storage_moved_failed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_failed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::storage_moved_failed_alert const *)arg1)->file_path();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1op_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::storage_moved_failed_alert *arg1 = 0 ;
  libtorrent::operation_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_failed_alert **)&jarg1; 
  arg2 = (libtorrent::operation_t)jarg2; 
  if (arg1) (arg1)->op = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1op_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::storage_moved_failed_alert *arg1 = 0 ;
  libtorrent::operation_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::storage_moved_failed_alert **)&jarg1; 
  result = (libtorrent::operation_t) ((arg1)->op);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1storage_1moved_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::storage_moved_failed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::storage_moved_failed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1deleted_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::torrent_deleted_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1deleted_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::torrent_deleted_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1deleted_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_deleted_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_deleted_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_deleted_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1deleted_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_deleted_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_deleted_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_deleted_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1deleted_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_deleted_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_deleted_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_deleted_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1deleted_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::torrent_deleted_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1deleted_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_deleted_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_deleted_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_deleted_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1deleted_1alert_1info_1hashes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_deleted_alert *arg1 = 0 ;
  libtorrent::info_hash_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_deleted_alert **)&jarg1; 
  arg2 = *(libtorrent::info_hash_t **)&jarg2; 
  if (arg1) (arg1)->info_hashes = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1deleted_1alert_1info_1hashes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_deleted_alert *arg1 = 0 ;
  libtorrent::info_hash_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_deleted_alert **)&jarg1; 
  result = (libtorrent::info_hash_t *)& ((arg1)->info_hashes);
  *(libtorrent::info_hash_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1deleted_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_deleted_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_deleted_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::torrent_delete_failed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::torrent_delete_failed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_delete_failed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_delete_failed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_delete_failed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_delete_failed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_delete_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_delete_failed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_delete_failed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_delete_failed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_delete_failed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::torrent_delete_failed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_delete_failed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_delete_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_delete_failed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_delete_failed_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_delete_failed_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1info_1hashes_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_delete_failed_alert *arg1 = 0 ;
  libtorrent::info_hash_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_delete_failed_alert **)&jarg1; 
  arg2 = *(libtorrent::info_hash_t **)&jarg2; 
  if (arg1) (arg1)->info_hashes = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1info_1hashes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_delete_failed_alert *arg1 = 0 ;
  libtorrent::info_hash_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_delete_failed_alert **)&jarg1; 
  result = (libtorrent::info_hash_t *)& ((arg1)->info_hashes);
  *(libtorrent::info_hash_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1delete_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_delete_failed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_delete_failed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::save_resume_data_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::save_resume_data_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::save_resume_data_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::save_resume_data_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::save_resume_data_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::save_resume_data_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::save_resume_data_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::save_resume_data_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::save_resume_data_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::save_resume_data_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::save_resume_data_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::save_resume_data_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::save_resume_data_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::save_resume_data_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::save_resume_data_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1alert_1params_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::save_resume_data_alert *arg1 = 0 ;
  libtorrent::add_torrent_params *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::save_resume_data_alert **)&jarg1; 
  arg2 = *(libtorrent::add_torrent_params **)&jarg2; 
  if (arg1) (arg1)->params = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1alert_1params_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::save_resume_data_alert *arg1 = 0 ;
  libtorrent::add_torrent_params *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::save_resume_data_alert **)&jarg1; 
  result = (libtorrent::add_torrent_params *)& ((arg1)->params);
  *(libtorrent::add_torrent_params **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1save_1resume_1data_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::save_resume_data_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::save_resume_data_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1failed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::save_resume_data_failed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1failed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::save_resume_data_failed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1failed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::save_resume_data_failed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::save_resume_data_failed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::save_resume_data_failed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1failed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::save_resume_data_failed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::save_resume_data_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::save_resume_data_failed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1failed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::save_resume_data_failed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::save_resume_data_failed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::save_resume_data_failed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1failed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::save_resume_data_failed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1failed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::save_resume_data_failed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::save_resume_data_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::save_resume_data_failed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1failed_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::save_resume_data_failed_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::save_resume_data_failed_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1save_1resume_1data_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::save_resume_data_failed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::save_resume_data_failed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1paused_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::torrent_paused_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1paused_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::torrent_paused_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1paused_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_paused_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_paused_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_paused_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1paused_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_paused_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_paused_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_paused_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1paused_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_paused_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_paused_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_paused_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1paused_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::torrent_paused_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1paused_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_paused_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_paused_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_paused_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1paused_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_paused_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_paused_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1resumed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::torrent_resumed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1resumed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::torrent_resumed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1resumed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_resumed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_resumed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_resumed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1resumed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_resumed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_resumed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_resumed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1resumed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_resumed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_resumed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_resumed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1resumed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::torrent_resumed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1resumed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_resumed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_resumed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_resumed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1resumed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_resumed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_resumed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1checked_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::torrent_checked_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1checked_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::torrent_checked_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1checked_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_checked_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_checked_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_checked_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1checked_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_checked_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_checked_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_checked_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1checked_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_checked_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_checked_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_checked_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1checked_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::torrent_checked_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1checked_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_checked_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_checked_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_checked_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1checked_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_checked_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_checked_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_url_1seed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::url_seed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_url_1seed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::url_seed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_url_1seed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::url_seed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::url_seed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::url_seed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_url_1seed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::url_seed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::url_seed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::url_seed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_url_1seed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::url_seed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::url_seed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::url_seed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_url_1seed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::url_seed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_url_1seed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::url_seed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::url_seed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::url_seed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_url_1seed_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::url_seed_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::url_seed_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_url_1seed_1alert_1server_1url(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::url_seed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::url_seed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::url_seed_alert const *)arg1)->server_url();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_url_1seed_1alert_1error_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::url_seed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::url_seed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::url_seed_alert const *)arg1)->error_message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1url_1seed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::url_seed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::url_seed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::file_error_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::file_error_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_error_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_error_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::file_error_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_error_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_error_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::file_error_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::file_error_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_error_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_error_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_error_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_error_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1op_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::file_error_alert *arg1 = 0 ;
  libtorrent::operation_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_error_alert **)&jarg1; 
  arg2 = (libtorrent::operation_t)jarg2; 
  if (arg1) (arg1)->op = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1op_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_error_alert *arg1 = 0 ;
  libtorrent::operation_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_error_alert **)&jarg1; 
  result = (libtorrent::operation_t) ((arg1)->op);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1filename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::file_error_alert const *)arg1)->filename();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::file_error_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::file_error_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1failed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::metadata_failed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1failed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::metadata_failed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1failed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::metadata_failed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::metadata_failed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::metadata_failed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1failed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::metadata_failed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::metadata_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::metadata_failed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1failed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::metadata_failed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::metadata_failed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::metadata_failed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1failed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::metadata_failed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1failed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::metadata_failed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::metadata_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::metadata_failed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1failed_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::metadata_failed_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::metadata_failed_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1metadata_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::metadata_failed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::metadata_failed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1received_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::metadata_received_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1received_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::metadata_received_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1received_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::metadata_received_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::metadata_received_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::metadata_received_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1received_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::metadata_received_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::metadata_received_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::metadata_received_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1received_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::metadata_received_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::metadata_received_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::metadata_received_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1received_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::metadata_received_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1received_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::metadata_received_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::metadata_received_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::metadata_received_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1metadata_1received_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::metadata_received_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::metadata_received_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::udp_error_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::udp_error_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::udp_error_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::udp_error_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::udp_error_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::udp_error_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::udp_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::udp_error_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::udp_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::udp_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::udp_error_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::udp_error_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::udp_error_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::udp_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::udp_error_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1operation_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::udp_error_alert *arg1 = 0 ;
  libtorrent::operation_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::udp_error_alert **)&jarg1; 
  arg2 = (libtorrent::operation_t)jarg2; 
  if (arg1) (arg1)->operation = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1operation_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::udp_error_alert *arg1 = 0 ;
  libtorrent::operation_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::udp_error_alert **)&jarg1; 
  result = (libtorrent::operation_t) ((arg1)->operation);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::udp_error_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::udp_error_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1get_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::udp_error_alert *arg1 = 0 ;
  libtorrent::udp::endpoint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::udp_error_alert **)&jarg1; 
  {
    try {
      result = libtorrent_udp_error_alert_get_endpoint(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::udp::endpoint **)&jresult = new libtorrent::udp::endpoint(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1udp_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::udp_error_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::udp_error_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_external_1ip_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::external_ip_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_external_1ip_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::external_ip_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_external_1ip_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::external_ip_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::external_ip_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::external_ip_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_external_1ip_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::external_ip_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::external_ip_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::external_ip_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_external_1ip_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::external_ip_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::external_ip_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::external_ip_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_external_1ip_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::external_ip_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_external_1ip_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::external_ip_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::external_ip_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::external_ip_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_external_1ip_1alert_1get_1external_1address(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::external_ip_alert *arg1 = 0 ;
  libtorrent::address result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::external_ip_alert **)&jarg1; 
  {
    try {
      result = libtorrent_external_ip_alert_get_external_address(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::address **)&jresult = new libtorrent::address(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1external_1ip_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::external_ip_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::external_ip_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::listen_failed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::listen_failed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::listen_failed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::listen_failed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::listen_failed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::listen_failed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::listen_failed_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1listen_1interface(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::listen_failed_alert const *)arg1)->listen_interface();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1op_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::listen_failed_alert *arg1 = 0 ;
  libtorrent::operation_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  arg2 = (libtorrent::operation_t)jarg2; 
  if (arg1) (arg1)->op = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1op_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = 0 ;
  libtorrent::operation_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  result = (libtorrent::operation_t) ((arg1)->op);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1port_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  result = (int)(int) ((arg1)->port);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1get_1socket_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  {
    try {
      result = (int)libtorrent_listen_failed_alert_get_socket_type(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1get_1address(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = 0 ;
  libtorrent::address result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  {
    try {
      result = libtorrent_listen_failed_alert_get_address(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::address **)&jresult = new libtorrent::address(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1listen_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::listen_failed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::listen_failed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::listen_succeeded_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::listen_succeeded_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::listen_succeeded_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_succeeded_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::listen_succeeded_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::listen_succeeded_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_succeeded_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::listen_succeeded_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::listen_succeeded_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_succeeded_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::listen_succeeded_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::listen_succeeded_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::listen_succeeded_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_succeeded_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::listen_succeeded_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1port_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::listen_succeeded_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_succeeded_alert **)&jarg1; 
  result = (int)(int) ((arg1)->port);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1get_1address(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::listen_succeeded_alert *arg1 = 0 ;
  libtorrent::address result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_succeeded_alert **)&jarg1; 
  {
    try {
      result = libtorrent_listen_succeeded_alert_get_address(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::address **)&jresult = new libtorrent::address(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1get_1socket_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::listen_succeeded_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_succeeded_alert **)&jarg1; 
  {
    try {
      result = (int)libtorrent_listen_succeeded_alert_get_socket_type(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1listen_1succeeded_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::listen_succeeded_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::listen_succeeded_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::portmap_error_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::portmap_error_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::portmap_error_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_error_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::portmap_error_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::portmap_error_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::portmap_error_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::portmap_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::portmap_error_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::portmap_error_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::portmap_error_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::portmap_error_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1map_1transport_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::portmap_error_alert *arg1 = 0 ;
  libtorrent::portmap_transport arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_error_alert **)&jarg1; 
  arg2 = (libtorrent::portmap_transport)jarg2; 
  if (arg1) (arg1)->map_transport = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1map_1transport_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::portmap_error_alert *arg1 = 0 ;
  libtorrent::portmap_transport result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_error_alert **)&jarg1; 
  result = (libtorrent::portmap_transport) ((arg1)->map_transport);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::portmap_error_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_error_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1get_1mapping(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::portmap_error_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_error_alert **)&jarg1; 
  {
    try {
      result = (int)libtorrent_portmap_error_alert_get_mapping(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1portmap_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::portmap_error_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::portmap_error_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::portmap_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::portmap_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::portmap_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::portmap_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::portmap_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::portmap_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::portmap_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::portmap_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::portmap_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::portmap_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::portmap_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1external_1port_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::portmap_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_alert **)&jarg1; 
  result = (int)(int) ((arg1)->external_port);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1map_1protocol_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::portmap_alert *arg1 = 0 ;
  libtorrent::portmap_protocol result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_alert **)&jarg1; 
  result = (libtorrent::portmap_protocol)(libtorrent::portmap_protocol) ((arg1)->map_protocol);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1map_1transport_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::portmap_alert *arg1 = 0 ;
  libtorrent::portmap_transport result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_alert **)&jarg1; 
  result = (libtorrent::portmap_transport)(libtorrent::portmap_transport) ((arg1)->map_transport);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1get_1mapping(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::portmap_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_alert **)&jarg1; 
  {
    try {
      result = (int)libtorrent_portmap_alert_get_mapping(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1portmap_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::portmap_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::portmap_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1log_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::portmap_log_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1log_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::portmap_log_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1log_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::portmap_log_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_log_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::portmap_log_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1log_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::portmap_log_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::portmap_log_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1log_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::portmap_log_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_log_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::portmap_log_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1log_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::portmap_log_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1log_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::portmap_log_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::portmap_log_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1log_1alert_1map_1transport_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::portmap_log_alert *arg1 = 0 ;
  libtorrent::portmap_transport result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_log_alert **)&jarg1; 
  result = (libtorrent::portmap_transport)(libtorrent::portmap_transport) ((arg1)->map_transport);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1log_1alert_1log_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::portmap_log_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_log_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::portmap_log_alert const *)arg1)->log_message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1portmap_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::portmap_log_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::portmap_log_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::fastresume_rejected_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::fastresume_rejected_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::fastresume_rejected_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::fastresume_rejected_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::fastresume_rejected_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::fastresume_rejected_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::fastresume_rejected_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::fastresume_rejected_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::fastresume_rejected_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::fastresume_rejected_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::fastresume_rejected_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::fastresume_rejected_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::fastresume_rejected_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::fastresume_rejected_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::fastresume_rejected_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1error_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::fastresume_rejected_alert *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::fastresume_rejected_alert **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2; 
  if (arg1) (arg1)->error = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::fastresume_rejected_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::fastresume_rejected_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1file_1path(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::fastresume_rejected_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::fastresume_rejected_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::fastresume_rejected_alert const *)arg1)->file_path();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1op_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::fastresume_rejected_alert *arg1 = 0 ;
  libtorrent::operation_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::fastresume_rejected_alert **)&jarg1; 
  arg2 = (libtorrent::operation_t)jarg2; 
  if (arg1) (arg1)->op = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1op_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::fastresume_rejected_alert *arg1 = 0 ;
  libtorrent::operation_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::fastresume_rejected_alert **)&jarg1; 
  result = (libtorrent::operation_t) ((arg1)->op);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1fastresume_1rejected_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::fastresume_rejected_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::fastresume_rejected_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1blocked_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::peer_blocked_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1blocked_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::peer_blocked_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1blocked_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_blocked_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_blocked_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::peer_blocked_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1blocked_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_blocked_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_blocked_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_blocked_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1blocked_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_blocked_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_blocked_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::peer_blocked_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1blocked_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::peer_blocked_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1blocked_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_blocked_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_blocked_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_blocked_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1blocked_1alert_1reason_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_blocked_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_blocked_alert **)&jarg1; 
  result = (int)(int) ((arg1)->reason);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1blocked_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_blocked_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_blocked_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_announce_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_announce_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_announce_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_announce_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_announce_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_announce_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_announce_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_announce_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_announce_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_announce_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_announce_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_announce_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_announce_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_announce_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_announce_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1port_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_announce_alert *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_announce_alert **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->port = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1port_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_announce_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_announce_alert **)&jarg1; 
  result = (int) ((arg1)->port);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1info_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_announce_alert *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_announce_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->info_hash = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1info_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_announce_alert *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_announce_alert **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->info_hash);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1get_1ip(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_announce_alert *arg1 = 0 ;
  libtorrent::address result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_announce_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_announce_alert_get_ip(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::address **)&jresult = new libtorrent::address(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1announce_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_announce_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_announce_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_get_peers_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_get_peers_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_get_peers_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_get_peers_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_get_peers_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_get_peers_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_get_peers_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_get_peers_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_get_peers_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_get_peers_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_get_peers_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1alert_1info_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_get_peers_alert *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_get_peers_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->info_hash = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1alert_1info_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_get_peers_alert *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_alert **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->info_hash);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1get_1peers_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_get_peers_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_get_peers_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_cache_1flushed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::cache_flushed_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_cache_1flushed_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::cache_flushed_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_cache_1flushed_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::cache_flushed_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::cache_flushed_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::cache_flushed_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_cache_1flushed_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::cache_flushed_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::cache_flushed_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::cache_flushed_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_cache_1flushed_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::cache_flushed_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::cache_flushed_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::cache_flushed_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_cache_1flushed_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::cache_flushed_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1cache_1flushed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::cache_flushed_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::cache_flushed_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1peer_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::lsd_peer_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1peer_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::lsd_peer_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1peer_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::lsd_peer_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::lsd_peer_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::lsd_peer_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1peer_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::lsd_peer_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::lsd_peer_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::lsd_peer_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1peer_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::lsd_peer_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::lsd_peer_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::lsd_peer_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1peer_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::lsd_peer_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1peer_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::lsd_peer_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::lsd_peer_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::lsd_peer_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1lsd_1peer_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::lsd_peer_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::lsd_peer_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_trackerid_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::trackerid_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_trackerid_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::trackerid_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_trackerid_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::trackerid_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::trackerid_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::trackerid_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_trackerid_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::trackerid_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::trackerid_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::trackerid_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_trackerid_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::trackerid_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::trackerid_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::trackerid_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_trackerid_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::trackerid_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_trackerid_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::trackerid_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::trackerid_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::trackerid_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_trackerid_1alert_1tracker_1id(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::trackerid_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::trackerid_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::trackerid_alert const *)arg1)->tracker_id();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1trackerid_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::trackerid_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::trackerid_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1bootstrap_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_bootstrap_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1bootstrap_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_bootstrap_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1bootstrap_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_bootstrap_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_bootstrap_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_bootstrap_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1bootstrap_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_bootstrap_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_bootstrap_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_bootstrap_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1bootstrap_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_bootstrap_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_bootstrap_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_bootstrap_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1bootstrap_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_bootstrap_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1bootstrap_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_bootstrap_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_bootstrap_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_bootstrap_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1bootstrap_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_bootstrap_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_bootstrap_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1error_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::torrent_error_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1error_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::torrent_error_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1error_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_error_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_error_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_error_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1error_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_error_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_error_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1error_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_error_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1error_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::torrent_error_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1error_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_error_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_error_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1error_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_error_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_error_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1error_1alert_1filename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_error_alert const *)arg1)->filename();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_error_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_error_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1need_1cert_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::torrent_need_cert_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1need_1cert_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::torrent_need_cert_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1need_1cert_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_need_cert_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_need_cert_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_need_cert_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1need_1cert_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_need_cert_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_need_cert_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_need_cert_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1need_1cert_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_need_cert_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_need_cert_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_need_cert_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1need_1cert_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::torrent_need_cert_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1need_1cert_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_need_cert_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_need_cert_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_need_cert_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1need_1cert_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_need_cert_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_need_cert_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1connection_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::incoming_connection_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1connection_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::incoming_connection_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1connection_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::incoming_connection_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_connection_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::incoming_connection_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1connection_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::incoming_connection_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_connection_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::incoming_connection_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1connection_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::incoming_connection_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_connection_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::incoming_connection_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1connection_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::incoming_connection_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1connection_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::incoming_connection_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_connection_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::incoming_connection_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1connection_1alert_1socket_1type_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::incoming_connection_alert *arg1 = 0 ;
  libtorrent::socket_type_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_connection_alert **)&jarg1; 
  arg2 = (libtorrent::socket_type_t)jarg2; 
  if (arg1) (arg1)->socket_type = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1connection_1alert_1socket_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::incoming_connection_alert *arg1 = 0 ;
  libtorrent::socket_type_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_connection_alert **)&jarg1; 
  result = (libtorrent::socket_type_t) ((arg1)->socket_type);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1connection_1alert_1get_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::incoming_connection_alert *arg1 = 0 ;
  libtorrent::tcp::endpoint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_connection_alert **)&jarg1; 
  {
    try {
      result = libtorrent_incoming_connection_alert_get_endpoint(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tcp::endpoint **)&jresult = new libtorrent::tcp::endpoint(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1incoming_1connection_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::incoming_connection_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::incoming_connection_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::add_torrent_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::add_torrent_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::add_torrent_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::add_torrent_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::add_torrent_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::add_torrent_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::add_torrent_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::add_torrent_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::add_torrent_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::add_torrent_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1params_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_alert *arg1 = 0 ;
  libtorrent::add_torrent_params *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_alert **)&jarg1; 
  arg2 = *(libtorrent::add_torrent_params **)&jarg2; 
  if (arg1) (arg1)->params = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1params_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_alert *arg1 = 0 ;
  libtorrent::add_torrent_params *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_alert **)&jarg1; 
  result = (libtorrent::add_torrent_params *)& ((arg1)->params);
  *(libtorrent::add_torrent_params **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1error_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_alert *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_alert **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2; 
  if (arg1) (arg1)->error = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1add_1torrent_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::add_torrent_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::add_torrent_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1update_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::state_update_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1update_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::state_update_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1update_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::state_update_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::state_update_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::state_update_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1update_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::state_update_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::state_update_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::state_update_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1update_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::state_update_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::state_update_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::state_update_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1update_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::state_update_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1update_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::state_update_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::state_update_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::state_update_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1update_1alert_1status_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::state_update_alert *arg1 = 0 ;
  std::vector< libtorrent::torrent_status > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::state_update_alert **)&jarg1; 
  arg2 = *(std::vector< libtorrent::torrent_status > **)&jarg2; 
  if (arg1) (arg1)->status = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1update_1alert_1status_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::state_update_alert *arg1 = 0 ;
  std::vector< libtorrent::torrent_status > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::state_update_alert **)&jarg1; 
  result = (std::vector< libtorrent::torrent_status > *)& ((arg1)->status);
  *(std::vector< libtorrent::torrent_status > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1state_1update_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::state_update_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::state_update_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::session_stats_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::session_stats_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::session_stats_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_stats_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::session_stats_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_stats_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_stats_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_stats_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::session_stats_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_stats_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::session_stats_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::session_stats_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::session_stats_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_stats_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_stats_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1alert_1get_1value(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::session_stats_alert *arg1 = 0 ;
  int arg2 ;
  long long result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_stats_alert **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (long long)libtorrent_session_stats_alert_get_value(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1session_1stats_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::session_stats_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::session_stats_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_error_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_error_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_error_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_error_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_error_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_error_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_error_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_error_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_error_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_error_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_error_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1error_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_error_alert *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_error_alert **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2; 
  if (arg1) (arg1)->error = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_error_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_error_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1op_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_error_alert *arg1 = 0 ;
  libtorrent::operation_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_error_alert **)&jarg1; 
  arg2 = (libtorrent::operation_t)jarg2; 
  if (arg1) (arg1)->op = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1op_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_error_alert *arg1 = 0 ;
  libtorrent::operation_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_error_alert **)&jarg1; 
  result = (libtorrent::operation_t) ((arg1)->op);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_error_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_error_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_immutable_item_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_immutable_item_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_immutable_item_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_immutable_item_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_immutable_item_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_immutable_item_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_immutable_item_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_immutable_item_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_immutable_item_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_immutable_item_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_immutable_item_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_immutable_item_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_immutable_item_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_immutable_item_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_immutable_item_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1target_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_immutable_item_alert *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_immutable_item_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->target = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1target_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_immutable_item_alert *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_immutable_item_alert **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->target);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1item_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_immutable_item_alert *arg1 = 0 ;
  libtorrent::entry *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_immutable_item_alert **)&jarg1; 
  arg2 = *(libtorrent::entry **)&jarg2; 
  if (arg1) (arg1)->item = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1item_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_immutable_item_alert *arg1 = 0 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_immutable_item_alert **)&jarg1; 
  result = (libtorrent::entry *)& ((arg1)->item);
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1immutable_1item_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_immutable_item_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_immutable_item_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_mutable_item_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_mutable_item_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_mutable_item_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_mutable_item_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_mutable_item_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_mutable_item_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_mutable_item_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1item_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  libtorrent::entry *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  arg2 = *(libtorrent::entry **)&jarg2; 
  if (arg1) (arg1)->item = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1item_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  result = (libtorrent::entry *)& ((arg1)->item);
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1authoritative_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->authoritative = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1authoritative_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  result = (bool) ((arg1)->authoritative);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1get_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_mutable_item_alert_get_key(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1get_1signature(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_mutable_item_alert_get_signature(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1get_1seq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_dht_mutable_item_alert_get_seq(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1get_1salt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_mutable_item_alert_get_salt(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1mutable_1item_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_mutable_item_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_mutable_item_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_put_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_put_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_put_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_put_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_put_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_put_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_put_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_put_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_put_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_put_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_put_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1target_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_put_alert *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->target = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1target_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_put_alert *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->target);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1num_1success_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_put_alert *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->num_success = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1num_1success_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_put_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  result = (int) ((arg1)->num_success);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1get_1public_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_put_alert *arg1 = 0 ;
  std::array< std::int8_t,32 > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_put_alert_get_public_key(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::array< std::int8_t,32 > **)&jresult = new std::array< std::int8_t,32 >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1get_1signature(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_put_alert *arg1 = 0 ;
  std::array< std::int8_t,64 > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_put_alert_get_signature(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::array< std::int8_t,64 > **)&jresult = new std::array< std::int8_t,64 >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1get_1salt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_put_alert *arg1 = 0 ;
  std::vector< std::int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_put_alert_get_salt(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = new std::vector< std::int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1get_1seq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_put_alert *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_dht_put_alert_get_seq(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1put_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_put_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_put_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_i2p_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::i2p_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_i2p_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::i2p_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_i2p_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::i2p_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::i2p_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::i2p_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_i2p_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::i2p_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::i2p_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::i2p_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_i2p_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::i2p_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::i2p_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::i2p_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_i2p_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::i2p_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_i2p_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::i2p_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::i2p_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::i2p_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_i2p_1alert_1error_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::i2p_alert *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::i2p_alert **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2; 
  if (arg1) (arg1)->error = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_i2p_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::i2p_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::i2p_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1i2p_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::i2p_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::i2p_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_outgoing_get_peers_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_outgoing_get_peers_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_outgoing_get_peers_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_outgoing_get_peers_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_outgoing_get_peers_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_outgoing_get_peers_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_outgoing_get_peers_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_outgoing_get_peers_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_outgoing_get_peers_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_outgoing_get_peers_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_outgoing_get_peers_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_outgoing_get_peers_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_outgoing_get_peers_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_outgoing_get_peers_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_outgoing_get_peers_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1info_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_outgoing_get_peers_alert *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_outgoing_get_peers_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->info_hash = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1info_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_outgoing_get_peers_alert *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_outgoing_get_peers_alert **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->info_hash);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1obfuscated_1info_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_outgoing_get_peers_alert *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_outgoing_get_peers_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->obfuscated_info_hash = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1obfuscated_1info_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_outgoing_get_peers_alert *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_outgoing_get_peers_alert **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->obfuscated_info_hash);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1get_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_outgoing_get_peers_alert *arg1 = 0 ;
  libtorrent::udp::endpoint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_outgoing_get_peers_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_outgoing_get_peers_alert_get_endpoint(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::udp::endpoint **)&jresult = new libtorrent::udp::endpoint(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1outgoing_1get_1peers_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_outgoing_get_peers_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_outgoing_get_peers_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_log_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::log_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_log_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::log_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_log_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::log_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::log_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::log_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_log_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::log_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::log_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_log_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::log_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::log_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::log_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_log_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::log_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_log_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::log_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::log_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_log_1alert_1log_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::log_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::log_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::log_alert const *)arg1)->log_message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::log_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::log_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1log_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::torrent_log_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1log_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::torrent_log_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1log_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_log_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_log_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_log_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1log_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_log_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_log_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1log_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_log_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_log_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_log_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1log_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::torrent_log_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1log_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_log_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_log_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1log_1alert_1log_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_log_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_log_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_log_alert const *)arg1)->log_message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_log_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_log_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::peer_log_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::peer_log_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_log_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_log_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::peer_log_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_log_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_log_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_log_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_log_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::peer_log_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::peer_log_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_log_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_log_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1direction_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_log_alert *arg1 = 0 ;
  libtorrent::peer_log_alert::direction_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_log_alert **)&jarg1; 
  arg2 = (libtorrent::peer_log_alert::direction_t)jarg2; 
  if (arg1) (arg1)->direction = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1direction_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_log_alert *arg1 = 0 ;
  libtorrent::peer_log_alert::direction_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_log_alert **)&jarg1; 
  result = (libtorrent::peer_log_alert::direction_t) ((arg1)->direction);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1log_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_log_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_log_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::peer_log_alert const *)arg1)->log_message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1get_1event_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_log_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_log_alert **)&jarg1; 
  {
    try {
      result = libtorrent_peer_log_alert_get_event_type(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_log_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_log_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1error_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::lsd_error_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1error_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::lsd_error_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1error_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::lsd_error_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::lsd_error_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::lsd_error_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1error_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::lsd_error_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::lsd_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::lsd_error_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1error_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::lsd_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::lsd_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::lsd_error_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1error_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::lsd_error_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1error_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::lsd_error_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::lsd_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::lsd_error_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1error_1alert_1error_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::lsd_error_alert *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::lsd_error_alert **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2; 
  if (arg1) (arg1)->error = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1error_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::lsd_error_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::lsd_error_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1lsd_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::lsd_error_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::lsd_error_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1outstanding_1requests_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_lookup *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->outstanding_requests = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1outstanding_1requests_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_lookup *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  result = (int) ((arg1)->outstanding_requests);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1timeouts_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_lookup *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->timeouts = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1timeouts_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_lookup *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  result = (int) ((arg1)->timeouts);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1responses_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_lookup *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->responses = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1responses_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_lookup *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  result = (int) ((arg1)->responses);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1branch_1factor_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_lookup *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->branch_factor = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1branch_1factor_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_lookup *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  result = (int) ((arg1)->branch_factor);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1nodes_1left_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_lookup *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->nodes_left = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1nodes_1left_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_lookup *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  result = (int) ((arg1)->nodes_left);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1last_1sent_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_lookup *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->last_sent = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1last_1sent_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_lookup *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  result = (int) ((arg1)->last_sent);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1first_1timeout_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_lookup *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->first_timeout = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1first_1timeout_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_lookup *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  result = (int) ((arg1)->first_timeout);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1target_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_lookup *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->target = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1target_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_lookup *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->target);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1get_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_lookup *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  {
    try {
      result = libtorrent_dht_lookup_get_type(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1dht_1lookup(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::dht_lookup *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::dht_lookup *)new libtorrent::dht_lookup();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::dht_lookup **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1lookup(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_lookup *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_lookup **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_stats_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_stats_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_stats_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_stats_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_stats_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_stats_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_stats_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_stats_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_stats_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_stats_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_stats_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1active_1requests_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_stats_alert *arg1 = 0 ;
  std::vector< libtorrent::dht_lookup > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  arg2 = *(std::vector< libtorrent::dht_lookup > **)&jarg2; 
  if (arg1) (arg1)->active_requests = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1active_1requests_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_stats_alert *arg1 = 0 ;
  std::vector< libtorrent::dht_lookup > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  result = (std::vector< libtorrent::dht_lookup > *)& ((arg1)->active_requests);
  *(std::vector< libtorrent::dht_lookup > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1routing_1table_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_stats_alert *arg1 = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  arg2 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg2; 
  if (arg1) (arg1)->routing_table = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1routing_1table_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_stats_alert *arg1 = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  result = (std::vector< libtorrent::dht_routing_bucket > *)& ((arg1)->routing_table);
  *(std::vector< libtorrent::dht_routing_bucket > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1nid_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_stats_alert *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->nid = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1nid_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_stats_alert *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->nid);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1get_1local_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_stats_alert *arg1 = 0 ;
  libtorrent::udp::endpoint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_stats_alert_get_local_endpoint(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::udp::endpoint **)&jresult = new libtorrent::udp::endpoint(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1stats_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_stats_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_stats_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1request_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::incoming_request_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1request_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::incoming_request_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1request_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::incoming_request_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1request_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::incoming_request_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_request_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::incoming_request_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1request_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::incoming_request_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_request_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::incoming_request_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1request_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::incoming_request_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_request_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::incoming_request_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1request_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::incoming_request_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_request_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::incoming_request_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1request_1alert_1req_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::incoming_request_alert *arg1 = 0 ;
  libtorrent::peer_request *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::incoming_request_alert **)&jarg1; 
  arg2 = *(libtorrent::peer_request **)&jarg2; 
  if (arg1) (arg1)->req = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1request_1alert_1req_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::incoming_request_alert *arg1 = 0 ;
  libtorrent::peer_request *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_request_alert **)&jarg1; 
  result = (libtorrent::peer_request *)& ((arg1)->req);
  *(libtorrent::peer_request **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1incoming_1request_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::incoming_request_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::incoming_request_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_log_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_log_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_log_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_log_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_log_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_log_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_log_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_log_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_log_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_log_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_log_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_log_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_log_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1alert_1log_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_log_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_log_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_log_alert const *)arg1)->log_message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1alert_1module_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_log_alert *arg1 = 0 ;
  libtorrent::dht_log_alert::dht_module_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_log_alert **)&jarg1; 
  arg2 = (libtorrent::dht_log_alert::dht_module_t)jarg2; 
  if (arg1) (arg1)->module = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1alert_1module_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_log_alert *arg1 = 0 ;
  libtorrent::dht_log_alert::dht_module_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_log_alert **)&jarg1; 
  result = (libtorrent::dht_log_alert::dht_module_t) ((arg1)->module);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_log_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_log_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_pkt_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_pkt_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_pkt_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_pkt_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_pkt_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_pkt_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_pkt_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_pkt_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_pkt_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_pkt_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_pkt_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_pkt_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_pkt_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_pkt_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_pkt_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1direction_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht_pkt_alert *arg1 = 0 ;
  libtorrent::dht_pkt_alert::direction_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_pkt_alert **)&jarg1; 
  arg2 = (libtorrent::dht_pkt_alert::direction_t)jarg2; 
  if (arg1) (arg1)->direction = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1direction_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_pkt_alert *arg1 = 0 ;
  libtorrent::dht_pkt_alert::direction_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_pkt_alert **)&jarg1; 
  result = (libtorrent::dht_pkt_alert::direction_t) ((arg1)->direction);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1get_1node(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_pkt_alert *arg1 = 0 ;
  libtorrent::udp::endpoint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_pkt_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_pkt_alert_get_node(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::udp::endpoint **)&jresult = new libtorrent::udp::endpoint(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1get_1pkt_1buf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_pkt_alert *arg1 = 0 ;
  std::vector< std::int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_pkt_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_pkt_alert_get_pkt_buf(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = new std::vector< std::int8_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1pkt_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_pkt_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_pkt_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_get_peers_reply_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_get_peers_reply_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_get_peers_reply_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_get_peers_reply_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_reply_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_get_peers_reply_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_get_peers_reply_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_reply_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_get_peers_reply_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_get_peers_reply_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_reply_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_get_peers_reply_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_get_peers_reply_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_reply_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_get_peers_reply_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1info_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_get_peers_reply_alert *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_get_peers_reply_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->info_hash = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1info_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_get_peers_reply_alert *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_reply_alert **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->info_hash);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1num_1peers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_get_peers_reply_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_reply_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_get_peers_reply_alert const *)arg1)->num_peers();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1peers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_get_peers_reply_alert *arg1 = 0 ;
  std::vector< libtorrent::tcp::endpoint > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_get_peers_reply_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_get_peers_reply_alert const *)arg1)->peers();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::tcp::endpoint > **)&jresult = new std::vector< libtorrent::tcp::endpoint >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1get_1peers_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_get_peers_reply_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_get_peers_reply_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1direct_1response_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_direct_response_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1direct_1response_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_direct_response_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1direct_1response_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_direct_response_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_direct_response_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_direct_response_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1direct_1response_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_direct_response_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_direct_response_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_direct_response_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1direct_1response_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_direct_response_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_direct_response_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_direct_response_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1direct_1response_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_direct_response_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1direct_1response_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_direct_response_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_direct_response_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_direct_response_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1direct_1response_1alert_1response(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_direct_response_alert *arg1 = 0 ;
  libtorrent::bdecode_node result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_direct_response_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_direct_response_alert const *)arg1)->response();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bdecode_node **)&jresult = new libtorrent::bdecode_node(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1direct_1response_1alert_1get_1userdata(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_direct_response_alert *arg1 = 0 ;
  libtorrent::client_data_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_direct_response_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_direct_response_alert_get_userdata(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::client_data_t **)&jresult = new libtorrent::client_data_t(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1direct_1response_1alert_1get_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_direct_response_alert *arg1 = 0 ;
  libtorrent::udp::endpoint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_direct_response_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_direct_response_alert_get_endpoint(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::udp::endpoint **)&jresult = new libtorrent::udp::endpoint(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1direct_1response_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_direct_response_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_direct_response_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::picker_log_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::picker_log_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::picker_log_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::picker_log_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::picker_log_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::picker_log_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::picker_log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::picker_log_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::picker_log_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::picker_log_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::picker_log_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::picker_log_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::picker_log_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::picker_log_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::picker_log_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1partial_1ratio_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::partial_ratio;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1prioritize_1partials_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::prioritize_partials;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1rarest_1first_1partials_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::rarest_first_partials;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1rarest_1first_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::rarest_first;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1reverse_1rarest_1first_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::reverse_rarest_first;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1suggested_1pieces_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::suggested_pieces;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1prio_1sequential_1pieces_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::prio_sequential_pieces;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1sequential_1pieces_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::sequential_pieces;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1reverse_1pieces_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::reverse_pieces;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1time_1critical_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::time_critical;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1random_1pieces_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::random_pieces;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1prefer_1contiguous_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::prefer_contiguous;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1reverse_1sequential_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::reverse_sequential;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1backup1_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::backup1;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1backup2_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::backup2;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1end_1game_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::end_game;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1extent_1affinity_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > *)&libtorrent::picker_log_alert::extent_affinity;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::picker_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1picker_1flags_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::picker_log_alert *arg1 = 0 ;
  libtorrent::picker_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::picker_log_alert **)&jarg1; 
  result = (libtorrent::picker_flags_t *)& ((arg1)->picker_flags);
  *(libtorrent::picker_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1picker_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::picker_log_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::picker_log_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1error_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::session_error_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1error_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::session_error_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1error_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::session_error_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_error_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::session_error_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1error_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_error_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_error_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1error_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::session_error_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_error_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::session_error_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1error_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::session_error_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1error_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::session_error_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_error_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_error_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1error_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_error_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_error_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1session_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::session_error_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::session_error_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_live_nodes_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_live_nodes_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_live_nodes_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_live_nodes_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_live_nodes_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_live_nodes_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_live_nodes_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_live_nodes_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_live_nodes_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_live_nodes_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_live_nodes_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_live_nodes_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_live_nodes_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_live_nodes_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_live_nodes_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1node_1id_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_live_nodes_alert *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_live_nodes_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->node_id = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1node_1id_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_live_nodes_alert *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_live_nodes_alert **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->node_id);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1num_1nodes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_live_nodes_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_live_nodes_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_live_nodes_alert const *)arg1)->num_nodes();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1nodes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_live_nodes_alert *arg1 = 0 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_live_nodes_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_live_nodes_alert const *)arg1)->nodes();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > **)&jresult = new std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1live_1nodes_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_live_nodes_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_live_nodes_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1header_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::session_stats_header_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1header_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::session_stats_header_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1header_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::session_stats_header_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_stats_header_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::session_stats_header_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1header_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_stats_header_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_stats_header_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_stats_header_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1header_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::session_stats_header_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_stats_header_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::session_stats_header_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1header_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::session_stats_header_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1header_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::session_stats_header_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_stats_header_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_stats_header_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1session_1stats_1header_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::session_stats_header_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::session_stats_header_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::dht_sample_infohashes_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::dht_sample_infohashes_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::dht_sample_infohashes_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_sample_infohashes_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_sample_infohashes_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::dht_sample_infohashes_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_sample_infohashes_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1node_1id_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->node_id = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1node_1id_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->node_id);
  *(libtorrent::sha1_hash **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1num_1infohashes_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  result = (int)(int) ((arg1)->num_infohashes);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1num_1samples(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_sample_infohashes_alert const *)arg1)->num_samples();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1samples(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  std::vector< libtorrent::sha1_hash > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_sample_infohashes_alert const *)arg1)->samples();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::sha1_hash > **)&jresult = new std::vector< libtorrent::sha1_hash >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1num_1nodes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::dht_sample_infohashes_alert const *)arg1)->num_nodes();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1nodes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_sample_infohashes_alert const *)arg1)->nodes();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > **)&jresult = new std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1get_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  libtorrent::udp::endpoint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  {
    try {
      result = libtorrent_dht_sample_infohashes_alert_get_endpoint(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::udp::endpoint **)&jresult = new libtorrent::udp::endpoint(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1get_1interval(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  {
    try {
      result = (std::int64_t)libtorrent_dht_sample_infohashes_alert_get_interval(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1sample_1infohashes_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_sample_infohashes_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht_sample_infohashes_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1uploaded_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::block_uploaded_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1uploaded_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::block_uploaded_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1uploaded_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::block_uploaded_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_uploaded_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::block_uploaded_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1uploaded_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::block_uploaded_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_uploaded_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::block_uploaded_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1uploaded_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::block_uploaded_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_uploaded_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::block_uploaded_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1uploaded_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::block_uploaded_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1uploaded_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::block_uploaded_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_uploaded_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::block_uploaded_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1uploaded_1alert_1block_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::block_uploaded_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_uploaded_alert **)&jarg1; 
  result = (int)(int) ((arg1)->block_index);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1uploaded_1alert_1piece_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::block_uploaded_alert *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::block_uploaded_alert **)&jarg1; 
  result = (piece_index_t) ((arg1)->piece_index);
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1block_1uploaded_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::block_uploaded_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::block_uploaded_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alerts_1dropped_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::alerts_dropped_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alerts_1dropped_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::alerts_dropped_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alerts_1dropped_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::alerts_dropped_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alerts_dropped_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::alerts_dropped_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alerts_1dropped_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alerts_dropped_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alerts_dropped_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::alerts_dropped_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alerts_1dropped_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::alerts_dropped_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alerts_dropped_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::alerts_dropped_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alerts_1dropped_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::alerts_dropped_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alerts_1dropped_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::alerts_dropped_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alerts_dropped_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::alerts_dropped_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alerts_1dropped_1alert_1dropped_1alerts_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::alerts_dropped_alert *arg1 = 0 ;
  std::bitset< 128 > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::alerts_dropped_alert **)&jarg1; 
  arg2 = *(std::bitset< 128 > **)&jarg2; 
  if (arg1) (arg1)->dropped_alerts = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alerts_1dropped_1alert_1dropped_1alerts_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alerts_dropped_alert *arg1 = 0 ;
  std::bitset< 128 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alerts_dropped_alert **)&jarg1; 
  result = (std::bitset< 128 > *)& ((arg1)->dropped_alerts);
  *(std::bitset< 128 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1alerts_1dropped_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::alerts_dropped_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::alerts_dropped_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::socks5_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::socks5_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::socks5_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::socks5_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::socks5_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::socks5_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::socks5_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::socks5_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::socks5_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::socks5_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::socks5_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::socks5_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::socks5_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::socks5_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::socks5_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1error_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::socks5_alert *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::socks5_alert **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2; 
  if (arg1) (arg1)->error = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::socks5_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::socks5_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1op_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::socks5_alert *arg1 = 0 ;
  libtorrent::operation_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::socks5_alert **)&jarg1; 
  arg2 = (libtorrent::operation_t)jarg2; 
  if (arg1) (arg1)->op = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1op_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::socks5_alert *arg1 = 0 ;
  libtorrent::operation_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::socks5_alert **)&jarg1; 
  result = (libtorrent::operation_t) ((arg1)->op);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1socks5_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::socks5_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::socks5_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::file_prio_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::file_prio_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_prio_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_prio_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::file_prio_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_prio_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_prio_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_prio_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_prio_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_prio_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::file_prio_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::file_prio_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_prio_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_prio_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_prio_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1error_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::file_prio_alert *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::file_prio_alert **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2; 
  if (arg1) (arg1)->error = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_prio_alert *arg1 = 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_prio_alert **)&jarg1; 
  result = (libtorrent::error_code *)& ((arg1)->error);
  *(libtorrent::error_code **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1op_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::file_prio_alert *arg1 = 0 ;
  libtorrent::operation_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_prio_alert **)&jarg1; 
  arg2 = (libtorrent::operation_t)jarg2; 
  if (arg1) (arg1)->op = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1op_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_prio_alert *arg1 = 0 ;
  libtorrent::operation_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_prio_alert **)&jarg1; 
  result = (libtorrent::operation_t) ((arg1)->op);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1prio_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::file_prio_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::file_prio_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_oversized_1file_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::oversized_file_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_oversized_1file_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::oversized_file_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_oversized_1file_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::oversized_file_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::oversized_file_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::oversized_file_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_oversized_1file_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::oversized_file_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::oversized_file_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::oversized_file_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_oversized_1file_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::oversized_file_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::oversized_file_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::oversized_file_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_oversized_1file_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::oversized_file_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_oversized_1file_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::oversized_file_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::oversized_file_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::oversized_file_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1oversized_1file_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::oversized_file_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::oversized_file_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1conflict_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::torrent_conflict_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1conflict_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::torrent_conflict_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1conflict_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_conflict_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_conflict_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_conflict_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1conflict_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_conflict_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_conflict_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_conflict_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1conflict_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_conflict_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_conflict_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::torrent_conflict_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1conflict_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::torrent_conflict_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1conflict_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_conflict_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_conflict_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_conflict_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1conflict_1alert_1conflicting_1torrent_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_conflict_alert *arg1 = 0 ;
  libtorrent::torrent_handle *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_conflict_alert **)&jarg1; 
  arg2 = *(libtorrent::torrent_handle **)&jarg2; 
  if (arg1) (arg1)->conflicting_torrent = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1conflict_1alert_1conflicting_1torrent_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_conflict_alert *arg1 = 0 ;
  libtorrent::torrent_handle *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_conflict_alert **)&jarg1; 
  result = (libtorrent::torrent_handle *)& ((arg1)->conflicting_torrent);
  *(libtorrent::torrent_handle **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1conflict_1alert_1get_1metadata(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_conflict_alert *arg1 = 0 ;
  SwigValueWrapper< libtorrent::torrent_info > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_conflict_alert **)&jarg1; 
  {
    try {
      result = libtorrent_torrent_conflict_alert_get_metadata(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_info **)&jresult = new libtorrent::torrent_info(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1torrent_1conflict_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_conflict_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::torrent_conflict_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::peer_info_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::peer_info_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::peer_info_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_info_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_info_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::peer_info_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::peer_info_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_info_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_info_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1alert_1peer_1info_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_info_alert *arg1 = 0 ;
  std::vector< libtorrent::peer_info > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_info_alert **)&jarg1; 
  arg2 = *(std::vector< libtorrent::peer_info > **)&jarg2; 
  if (arg1) (arg1)->peer_info = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1alert_1peer_1info_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info_alert *arg1 = 0 ;
  std::vector< libtorrent::peer_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info_alert **)&jarg1; 
  result = (std::vector< libtorrent::peer_info > *)& ((arg1)->peer_info);
  *(std::vector< libtorrent::peer_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1info_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_info_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_info_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::file_progress_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::file_progress_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::file_progress_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_progress_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::file_progress_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_progress_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_progress_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_progress_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_progress_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_progress_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::file_progress_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::file_progress_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::file_progress_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_progress_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::file_progress_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1alert_1get_1files(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_progress_alert *arg1 = 0 ;
  std::vector< std::int64_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_progress_alert **)&jarg1; 
  {
    try {
      result = libtorrent_file_progress_alert_get_files(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int64_t > **)&jresult = new std::vector< std::int64_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1progress_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::file_progress_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::file_progress_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::piece_info_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::piece_info_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::piece_info_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_info_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::piece_info_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::piece_info_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_info_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::piece_info_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::piece_info_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_info_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::piece_info_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::piece_info_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::piece_info_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_info_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::piece_info_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1piece_1info_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::piece_info_alert *arg1 = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::piece_info_alert **)&jarg1; 
  arg2 = *(std::vector< libtorrent::partial_piece_info > **)&jarg2; 
  if (arg1) (arg1)->piece_info = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1piece_1info_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::piece_info_alert *arg1 = 0 ;
  std::vector< libtorrent::partial_piece_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_info_alert **)&jarg1; 
  result = (std::vector< libtorrent::partial_piece_info > *)& ((arg1)->piece_info);
  *(std::vector< libtorrent::partial_piece_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1block_1data_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::piece_info_alert *arg1 = 0 ;
  std::vector< libtorrent::block_info > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::piece_info_alert **)&jarg1; 
  arg2 = *(std::vector< libtorrent::block_info > **)&jarg2; 
  if (arg1) (arg1)->block_data = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1block_1data_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::piece_info_alert *arg1 = 0 ;
  std::vector< libtorrent::block_info > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_info_alert **)&jarg1; 
  result = (std::vector< libtorrent::block_info > *)& ((arg1)->block_data);
  *(std::vector< libtorrent::block_info > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1piece_1info_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::piece_info_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::piece_info_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1availability_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::piece_availability_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1availability_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::piece_availability_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1availability_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::piece_availability_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_availability_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::piece_availability_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1availability_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::piece_availability_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_availability_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::piece_availability_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1availability_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::piece_availability_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_availability_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::piece_availability_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1availability_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::piece_availability_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1availability_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::piece_availability_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_availability_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::piece_availability_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1availability_1alert_1piece_1availability_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::piece_availability_alert *arg1 = 0 ;
  std::vector< int > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::piece_availability_alert **)&jarg1; 
  arg2 = *(std::vector< int > **)&jarg2; 
  if (arg1) (arg1)->piece_availability = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1availability_1alert_1piece_1availability_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::piece_availability_alert *arg1 = 0 ;
  std::vector< int > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::piece_availability_alert **)&jarg1; 
  result = (std::vector< int > *)& ((arg1)->piece_availability);
  *(std::vector< int > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1piece_1availability_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::piece_availability_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::piece_availability_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1list_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::alert_priority result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::alert_priority)libtorrent::tracker_list_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1list_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::tracker_list_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1list_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::tracker_list_alert *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_list_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::tracker_list_alert const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1list_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::tracker_list_alert *arg1 = 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_list_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::tracker_list_alert const *)arg1)->category();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert_category_t **)&jresult = new libtorrent::alert_category_t(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1list_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_list_alert *arg1 = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_list_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::tracker_list_alert const *)arg1)->what();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1list_1alert_1static_1category_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > *)&libtorrent::tracker_list_alert::static_category;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1list_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::tracker_list_alert *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_list_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::tracker_list_alert const *)arg1)->message();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1list_1alert_1trackers_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::tracker_list_alert *arg1 = 0 ;
  std::vector< libtorrent::announce_entry > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::tracker_list_alert **)&jarg1; 
  arg2 = *(std::vector< libtorrent::announce_entry > **)&jarg2; 
  if (arg1) (arg1)->trackers = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1list_1alert_1trackers_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::tracker_list_alert *arg1 = 0 ;
  std::vector< libtorrent::announce_entry > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_list_alert **)&jarg1; 
  result = (std::vector< libtorrent::announce_entry > *)& ((arg1)->trackers);
  *(std::vector< libtorrent::announce_entry > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1tracker_1list_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::tracker_list_alert *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::tracker_list_alert **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1alert_1category_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *)new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1category_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_alert_category_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1alert_1category_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_name_1for_1setting(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jstring jresult = 0 ;
  int arg1 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = (char *)libtorrent::name_for_setting(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_default_1settings(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::settings_pack result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::default_settings();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::settings_pack **)&jresult = new libtorrent::settings_pack(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1interface_1set_1str(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
  libtorrent::settings_interface *arg1 = 0 ;
  int arg2 ;
  std::string arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_interface **)&jarg1; 
  arg2 = (int)jarg2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  } 
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  (&arg3)->assign(arg3_pstr);
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      (arg1)->set_str(arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1interface_1set_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  libtorrent::settings_interface *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_interface **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      (arg1)->set_int(arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1interface_1set_1bool(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
  libtorrent::settings_interface *arg1 = 0 ;
  int arg2 ;
  bool arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_interface **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      (arg1)->set_bool(arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1interface_1has_1val(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jboolean jresult = 0 ;
  libtorrent::settings_interface *arg1 = 0 ;
  int arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_interface **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (bool)((libtorrent::settings_interface const *)arg1)->has_val(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1interface_1get_1str(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jstring jresult = 0 ;
  libtorrent::settings_interface *arg1 = 0 ;
  int arg2 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_interface **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (std::string *) &((libtorrent::settings_interface const *)arg1)->get_str(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1interface_1get_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jint jresult = 0 ;
  libtorrent::settings_interface *arg1 = 0 ;
  int arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_interface **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (int)((libtorrent::settings_interface const *)arg1)->get_int(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1interface_1get_1bool(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jboolean jresult = 0 ;
  libtorrent::settings_interface *arg1 = 0 ;
  int arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_interface **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (bool)((libtorrent::settings_interface const *)arg1)->get_bool(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1settings_1pack_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::settings_pack *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::settings_pack *)new libtorrent::settings_pack();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::settings_pack **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1settings_1pack_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::settings_pack *arg1 = 0 ;
  libtorrent::settings_pack *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::settings_pack const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::settings_pack *)new libtorrent::settings_pack((libtorrent::settings_pack const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::settings_pack **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1set_1str(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
  libtorrent::settings_pack *arg1 = 0 ;
  int arg2 ;
  std::string arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  arg2 = (int)jarg2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  } 
  const char *arg3_pstr = jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  (&arg3)->assign(arg3_pstr);
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      (arg1)->set_str(arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1set_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  libtorrent::settings_pack *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      (arg1)->set_int(arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1set_1bool(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
  libtorrent::settings_pack *arg1 = 0 ;
  int arg2 ;
  bool arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try {
      (arg1)->set_bool(arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1has_1val(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jboolean jresult = 0 ;
  libtorrent::settings_pack *arg1 = 0 ;
  int arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (bool)((libtorrent::settings_pack const *)arg1)->has_val(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1clear_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::settings_pack *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1clear_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::settings_pack *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      (arg1)->clear(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1get_1str(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jstring jresult = 0 ;
  libtorrent::settings_pack *arg1 = 0 ;
  int arg2 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (std::string *) &((libtorrent::settings_pack const *)arg1)->get_str(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1get_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jint jresult = 0 ;
  libtorrent::settings_pack *arg1 = 0 ;
  int arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (int)((libtorrent::settings_pack const *)arg1)->get_int(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1get_1bool(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jboolean jresult = 0 ;
  libtorrent::settings_pack *arg1 = 0 ;
  int arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (bool)((libtorrent::settings_pack const *)arg1)->get_bool(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1string_1type_1base_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::type_bases result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::type_bases)libtorrent::settings_pack::string_type_base;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1int_1type_1base_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::type_bases result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::type_bases)libtorrent::settings_pack::int_type_base;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1bool_1type_1base_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::type_bases result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::type_bases)libtorrent::settings_pack::bool_type_base;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1type_1mask_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::type_bases result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::type_bases)libtorrent::settings_pack::type_mask;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1index_1mask_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::type_bases result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::type_bases)libtorrent::settings_pack::index_mask;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1user_1agent_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::string_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::string_types)libtorrent::settings_pack::user_agent;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1handshake_1client_1version_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::string_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::string_types)libtorrent::settings_pack::handshake_client_version;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1allow_1multiple_1connections_1per_1ip_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::allow_multiple_connections_per_ip;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1send_1redundant_1have_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::send_redundant_have;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1use_1dht_1as_1fallback_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::use_dht_as_fallback;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1auto_1manage_1prefer_1seeds_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::auto_manage_prefer_seeds;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1disable_1hash_1checks_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::disable_hash_checks;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1no_1atime_1storage_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::no_atime_storage;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1enable_1outgoing_1utp_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::enable_outgoing_utp;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1no_1recheck_1incomplete_1resume_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::no_recheck_incomplete_resume;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1seeding_1outgoing_1connections_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::seeding_outgoing_connections;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1ban_1web_1seeds_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::ban_web_seeds;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1support_1share_1mode_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::support_share_mode;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1report_1redundant_1bytes_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::report_redundant_bytes;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1announce_1crypto_1support_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bool_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bool_types)libtorrent::settings_pack::announce_crypto_support;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1tracker_1completion_1timeout_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::tracker_completion_timeout;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1disk_1io_1write_1mode_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::disk_io_write_mode;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1active_1downloads_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::active_downloads;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1auto_1manage_1interval_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::auto_manage_interval;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1optimistic_1disk_1retry_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::optimistic_disk_retry;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1num_1optimistic_1unchoke_1slots_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::num_optimistic_unchoke_slots;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1max_1pex_1peers_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::max_pex_peers;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1dht_1upload_1rate_1limit_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::dht_upload_rate_limit;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1connections_1limit_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::connections_limit;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1utp_1loss_1multiplier_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::utp_loss_multiplier;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1tracker_1backoff_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::tracker_backoff;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1urlseed_1max_1request_1bytes_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::int_types result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::int_types)libtorrent::settings_pack::urlseed_max_request_bytes;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1num_1string_1settings_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::settings_pack::num_string_settings;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1num_1bool_1settings_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::settings_pack::num_bool_settings;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1num_1int_1settings_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::settings_pack::num_int_settings;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1always_1pwrite_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::mmap_write_mode_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::mmap_write_mode_t)libtorrent::settings_pack::always_pwrite;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1no_1piece_1suggestions_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::suggest_mode_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::suggest_mode_t)libtorrent::settings_pack::no_piece_suggestions;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1suggest_1read_1cache_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::suggest_mode_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::suggest_mode_t)libtorrent::settings_pack::suggest_read_cache;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1fixed_1slots_1choker_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::choking_algorithm_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::choking_algorithm_t)libtorrent::settings_pack::fixed_slots_choker;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1rate_1based_1choker_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::choking_algorithm_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::choking_algorithm_t)libtorrent::settings_pack::rate_based_choker;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1enable_1os_1cache_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::io_buffer_mode_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::io_buffer_mode_t)libtorrent::settings_pack::enable_os_cache;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1disable_1os_1cache_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::io_buffer_mode_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::io_buffer_mode_t)libtorrent::settings_pack::disable_os_cache;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1write_1through_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::io_buffer_mode_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::io_buffer_mode_t)libtorrent::settings_pack::write_through;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1prefer_1tcp_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bandwidth_mixed_algo_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bandwidth_mixed_algo_t)libtorrent::settings_pack::prefer_tcp;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1peer_1proportional_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::bandwidth_mixed_algo_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::bandwidth_mixed_algo_t)libtorrent::settings_pack::peer_proportional;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1pe_1plaintext_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::enc_level result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::enc_level)libtorrent::settings_pack::pe_plaintext;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1pe_1rc4_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::enc_level result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::enc_level)libtorrent::settings_pack::pe_rc4;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1pe_1both_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::enc_level result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::enc_level)libtorrent::settings_pack::pe_both;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1get_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::settings_pack *arg1 = 0 ;
  int arg2 ;
  std::vector< std::int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = libtorrent_settings_pack_get_bytes(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = new std::vector< std::int8_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1set_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  libtorrent::settings_pack *arg1 = 0 ;
  int arg2 ;
  std::vector< std::int8_t > arg3 ;
  std::vector< std::int8_t > *argp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  arg2 = (int)jarg2; 
  argp3 = *(std::vector< std::int8_t > **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::int8_t >");
    return ;
  }
  arg3 = *argp3; 
  {
    try {
      libtorrent_settings_pack_set_bytes(arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1settings_1pack(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::settings_pack *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::settings_pack **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1ignore_1unchoke_1slots_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::peer_class_info *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->ignore_unchoke_slots = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1ignore_1unchoke_1slots_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_class_info *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  result = (bool) ((arg1)->ignore_unchoke_slots);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1connection_1limit_1factor_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_class_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->connection_limit_factor = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1connection_1limit_1factor_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_class_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  result = (int) ((arg1)->connection_limit_factor);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1label_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::peer_class_info *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  if (arg1) (arg1)->label = *arg2;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1label_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::peer_class_info *arg1 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  result = (std::string *) & ((arg1)->label);
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1upload_1limit_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_class_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->upload_limit = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1upload_1limit_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_class_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  result = (int) ((arg1)->upload_limit);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1download_1limit_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_class_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->download_limit = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1download_1limit_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_class_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  result = (int) ((arg1)->download_limit);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1upload_1priority_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_class_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->upload_priority = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1upload_1priority_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_class_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  result = (int) ((arg1)->upload_priority);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1download_1priority_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_class_info *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->download_priority = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1info_1download_1priority_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_class_info *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  result = (int) ((arg1)->download_priority);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1peer_1class_1info(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::peer_class_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::peer_class_info *)new libtorrent::peer_class_info();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_class_info **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1class_1info(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_class_info *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_class_info **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1peer_1class_1type_1filter(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::peer_class_type_filter *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::peer_class_type_filter *)new libtorrent::peer_class_type_filter();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_class_type_filter **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1type_1filter_1tcp_1socket_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::peer_class_type_filter::socket_type_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::peer_class_type_filter::socket_type_t)libtorrent::peer_class_type_filter::tcp_socket;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1type_1filter_1apply(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  jlong jresult = 0 ;
  libtorrent::peer_class_type_filter *arg1 = 0 ;
  libtorrent::peer_class_type_filter::socket_type_t arg2 ;
  std::uint32_t arg3 ;
  std::uint32_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_type_filter **)&jarg1; 
  arg2 = (libtorrent::peer_class_type_filter::socket_type_t)jarg2; 
  arg3 = (std::uint32_t)jarg3; 
  {
    try {
      result = (std::uint32_t)(arg1)->apply(arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1class_1type_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_class_type_filter *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_class_type_filter **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1ip_1filter_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::ip_filter *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::ip_filter *)new libtorrent::ip_filter();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::ip_filter **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1ip_1filter_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::ip_filter *arg1 = 0 ;
  libtorrent::ip_filter *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::ip_filter **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::ip_filter const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::ip_filter *)new libtorrent::ip_filter((libtorrent::ip_filter const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::ip_filter **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1filter_1blocked_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::ip_filter::access_flags result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::ip_filter::access_flags)libtorrent::ip_filter::blocked;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1filter_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::ip_filter *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::ip_filter **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::ip_filter const *)arg1)->empty();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1filter_1add_1rule(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4) {
  libtorrent::ip_filter *arg1 = 0 ;
  libtorrent::address *arg2 = 0 ;
  libtorrent::address *arg3 = 0 ;
  std::uint32_t arg4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::ip_filter **)&jarg1; 
  arg2 = *(libtorrent::address **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::address const & is null");
    return ;
  } 
  arg3 = *(libtorrent::address **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::address const & is null");
    return ;
  } 
  arg4 = (std::uint32_t)jarg4; 
  {
    try {
      (arg1)->add_rule((libtorrent::address const &)*arg2,(libtorrent::address const &)*arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1filter_1access(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::ip_filter *arg1 = 0 ;
  libtorrent::address *arg2 = 0 ;
  std::uint32_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::ip_filter **)&jarg1; 
  arg2 = *(libtorrent::address **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::address const & is null");
    return 0;
  } 
  {
    try {
      result = (std::uint32_t)((libtorrent::ip_filter const *)arg1)->access((libtorrent::address const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1ip_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::ip_filter *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::ip_filter **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1port_1filter_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::port_filter *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::port_filter *)new libtorrent::port_filter();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::port_filter **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1port_1filter_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::port_filter *arg1 = 0 ;
  libtorrent::port_filter *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::port_filter **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::port_filter const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::port_filter *)new libtorrent::port_filter((libtorrent::port_filter const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::port_filter **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1port_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::port_filter *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::port_filter **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_port_1filter_1blocked_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::port_filter::access_flags result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::port_filter::access_flags)libtorrent::port_filter::blocked;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_port_1filter_1add_1rule(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jlong jarg4) {
  libtorrent::port_filter *arg1 = 0 ;
  std::uint16_t arg2 ;
  std::uint16_t arg3 ;
  std::uint32_t arg4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::port_filter **)&jarg1; 
  arg2 = (std::uint16_t)jarg2; 
  arg3 = (std::uint16_t)jarg3; 
  arg4 = (std::uint32_t)jarg4; 
  {
    try {
      (arg1)->add_rule(arg2,arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_port_1filter_1access(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::port_filter *arg1 = 0 ;
  std::uint16_t arg2 ;
  std::uint32_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::port_filter **)&jarg1; 
  arg2 = (std::uint16_t)jarg2; 
  {
    try {
      result = (std::uint32_t)((libtorrent::port_filter const *)arg1)->access(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1remove_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_remove_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_remove_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_remove_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_remove_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_remove_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_remove_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_remove_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_remove_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_remove_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_remove_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_remove_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_remove_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1remove_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1save_1state_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1state_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1state_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1state_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1state_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1state_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1state_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1state_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1state_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1state_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1state_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1state_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint32_t_Sc_libtorrent_save_state_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1save_1state_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_session_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1session_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1reopen_1network_1flags_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *)new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reopen_1network_1flags_1t_1all(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag >::SWIGTEMPLATEDISAMBIGUATOR all();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reopen_1network_1flags_1t_1non_1zero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__non_zero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reopen_1network_1flags_1t_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg1; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__nonZero(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reopen_1network_1flags_1t_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__eq(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reopen_1network_1flags_1t_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (bool)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__ne(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reopen_1network_1flags_1t_1or_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__or_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reopen_1network_1flags_1t_1and_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__and_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reopen_1network_1flags_1t_1xor_1(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > arg2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const *argp2 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg1; 
  argp2 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__xor_(arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reopen_1network_1flags_1t_1inv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *arg1 = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__inv(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reopen_1network_1flags_1t_1to_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg1; 
  {
    try {
      result = (int)libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__to_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_reopen_1network_1flags_1t_1from_1int(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = libtorrent_flags_bitfield_flag_Sl_std_uint8_t_Sc_libtorrent_reopen_network_flags_tag_Sg__from_int(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jresult = new libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1reopen_1network_1flags_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1params_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::settings_pack *arg1 = 0 ;
  libtorrent::session_params *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::settings_pack const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::session_params *)new libtorrent::session_params((libtorrent::settings_pack const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_params **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1params_1_1SWIG_11(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::session_params *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::session_params *)new libtorrent::session_params();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_params **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1session_1params(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::session_params *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1params_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::session_params *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::session_params const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::session_params *)new libtorrent::session_params((libtorrent::session_params const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_params **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1settings_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::settings_pack *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  arg2 = *(libtorrent::settings_pack **)&jarg2; 
  if (arg1) (arg1)->settings = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1settings_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::settings_pack *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  result = (libtorrent::settings_pack *)& ((arg1)->settings);
  *(libtorrent::settings_pack **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1dht_1state_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::dht::dht_state *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  arg2 = *(libtorrent::dht::dht_state **)&jarg2; 
  if (arg1) (arg1)->dht_state = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1dht_1state_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::dht::dht_state *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  result = (libtorrent::dht::dht_state *)& ((arg1)->dht_state);
  *(libtorrent::dht::dht_state **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1ext_1state_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_params *arg1 = 0 ;
  std::map< std::string,std::string,std::less< std::string > > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  arg2 = *(std::map< std::string,std::string,std::less< std::string > > **)&jarg2; 
  if (arg1) (arg1)->ext_state = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1ext_1state_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = 0 ;
  std::map< std::string,std::string,std::less< std::string > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  result = (std::map< std::string,std::string,std::less< std::string > > *)& ((arg1)->ext_state);
  *(std::map< std::string,std::string,std::less< std::string > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1ip_1filter_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::ip_filter *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  arg2 = *(libtorrent::ip_filter **)&jarg2; 
  if (arg1) (arg1)->ip_filter = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1ip_1filter_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::ip_filter *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  result = (libtorrent::ip_filter *)& ((arg1)->ip_filter);
  *(libtorrent::ip_filter **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1read_1session_1params_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  libtorrent::save_state_flags_t arg2 ;
  libtorrent::save_state_flags_t *argp2 ;
  libtorrent::session_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & is null");
    return 0;
  } 
  argp2 = *(libtorrent::save_state_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::save_state_flags_t");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_session_params_read_session_params__SWIG_0((libtorrent::bdecode_node const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_params **)&jresult = new libtorrent::session_params(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1read_1session_1params_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  libtorrent::session_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_session_params_read_session_params__SWIG_0((libtorrent::bdecode_node const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_params **)&jresult = new libtorrent::session_params(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1write_1session_1params_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::save_state_flags_t arg2 ;
  libtorrent::save_state_flags_t *argp2 ;
  libtorrent::entry result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::session_params const & is null");
    return 0;
  } 
  argp2 = *(libtorrent::save_state_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::save_state_flags_t");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_session_params_write_session_params__SWIG_0((libtorrent::session_params const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = new libtorrent::entry(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1write_1session_1params_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::entry result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::session_params const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_session_params_write_session_params__SWIG_0((libtorrent::session_params const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = new libtorrent::entry(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1write_1session_1params_1buf_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::save_state_flags_t arg2 ;
  libtorrent::save_state_flags_t *argp2 ;
  std::vector< std::int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::session_params const & is null");
    return 0;
  } 
  argp2 = *(libtorrent::save_state_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::save_state_flags_t");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent_session_params_write_session_params_buf__SWIG_0((libtorrent::session_params const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = new std::vector< std::int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1write_1session_1params_1buf_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = 0 ;
  std::vector< std::int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::session_params const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent_session_params_write_session_params_buf__SWIG_0((libtorrent::session_params const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = new std::vector< std::int8_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1set_1posix_1disk_1io_1constructor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::session_params *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  {
    try {
      libtorrent_session_params_set_posix_disk_io_constructor(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1set_1default_1disk_1io_1constructor(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::session_params *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  {
    try {
      libtorrent_session_params_set_default_disk_io_constructor(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1handle_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::session_handle *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::session_handle *)new libtorrent::session_handle();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_handle **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1handle_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::session_handle *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::session_handle const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::session_handle *)new libtorrent::session_handle((libtorrent::session_handle const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_handle **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1is_1valid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::session_handle const *)arg1)->is_valid();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1save_1settings_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > *)&libtorrent::session_handle::save_settings;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1save_1dht_1state_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > *)&libtorrent::session_handle::save_dht_state;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1save_1extension_1state_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > *)&libtorrent::session_handle::save_extension_state;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1save_1ip_1filter_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > *)&libtorrent::session_handle::save_ip_filter;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::save_state_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1session_1state_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::save_state_flags_t arg2 ;
  libtorrent::save_state_flags_t *argp2 ;
  libtorrent::session_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  argp2 = *(libtorrent::save_state_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::save_state_flags_t");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = ((libtorrent::session_handle const *)arg1)->session_state(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_params **)&jresult = new libtorrent::session_params(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1session_1state_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::session_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_handle const *)arg1)->session_state();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_params **)&jresult = new libtorrent::session_params(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1refresh_1torrent_1status_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  libtorrent::session_handle *arg1 = 0 ;
  std::vector< libtorrent::torrent_status > *arg2 = 0 ;
  libtorrent::status_flags_t arg3 ;
  libtorrent::status_flags_t *argp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(std::vector< libtorrent::torrent_status > **)&jarg2; 
  argp3 = *(libtorrent::status_flags_t **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::status_flags_t");
    return ;
  }
  arg3 = *argp3; 
  {
    try {
      ((libtorrent::session_handle const *)arg1)->refresh_torrent_status(arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1refresh_1torrent_1status_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  std::vector< libtorrent::torrent_status > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(std::vector< libtorrent::torrent_status > **)&jarg2; 
  {
    try {
      ((libtorrent::session_handle const *)arg1)->refresh_torrent_status(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1post_1torrent_1updates_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::status_flags_t arg2 ;
  libtorrent::status_flags_t *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  argp2 = *(libtorrent::status_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::status_flags_t");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      (arg1)->post_torrent_updates(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1post_1torrent_1updates_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::session_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      (arg1)->post_torrent_updates();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1post_1session_1stats(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::session_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      (arg1)->post_session_stats();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1post_1dht_1stats(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::session_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      (arg1)->post_dht_stats();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1set_1dht_1state_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::dht::dht_state *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::dht::dht_state **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::dht::dht_state const & is null");
    return ;
  } 
  {
    try {
      (arg1)->set_dht_state((libtorrent::dht::dht_state const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1find_1torrent_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  libtorrent::torrent_handle result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return 0;
  } 
  {
    try {
      result = ((libtorrent::session_handle const *)arg1)->find_torrent((libtorrent::sha1_hash const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_handle **)&jresult = new libtorrent::torrent_handle(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1find_1torrent_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::sha256_hash *arg2 = 0 ;
  libtorrent::torrent_handle result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::sha256_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha256_hash const & is null");
    return 0;
  } 
  {
    try {
      result = ((libtorrent::session_handle const *)arg1)->find_torrent((libtorrent::sha256_hash const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_handle **)&jresult = new libtorrent::torrent_handle(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1get_1torrents(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  std::vector< libtorrent::torrent_handle > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_handle const *)arg1)->get_torrents();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::torrent_handle > **)&jresult = new std::vector< libtorrent::torrent_handle >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1add_1torrent(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::add_torrent_params *arg2 = 0 ;
  libtorrent::error_code *arg3 = 0 ;
  libtorrent::torrent_handle result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::add_torrent_params **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::add_torrent_params const & is null");
    return 0;
  } 
  arg3 = *(libtorrent::error_code **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  {
    try {
      result = (arg1)->add_torrent((libtorrent::add_torrent_params const &)*arg2,*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_handle **)&jresult = new libtorrent::torrent_handle(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1async_1add_1torrent(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::add_torrent_params *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::add_torrent_params **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::add_torrent_params const & is null");
    return ;
  } 
  {
    try {
      (arg1)->async_add_torrent((libtorrent::add_torrent_params const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1pause(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::session_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      (arg1)->pause();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1resume(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::session_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      (arg1)->resume();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1is_1paused(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::session_handle const *)arg1)->is_paused();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1is_1dht_1running(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::session_handle const *)arg1)->is_dht_running();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1add_1dht_1node(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  std::pair< std::string,int > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(std::pair< std::string,int > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< std::string,int > const & is null");
    return ;
  } 
  {
    try {
      (arg1)->add_dht_node((std::pair< std::string,int > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1get_1item_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return ;
  } 
  {
    try {
      (arg1)->dht_get_item((libtorrent::sha1_hash const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1put_1item_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::entry arg2 ;
  libtorrent::entry *argp2 ;
  libtorrent::sha1_hash result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  argp2 = *(libtorrent::entry **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::entry");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (arg1)->dht_put_item(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::sha1_hash **)&jresult = new libtorrent::sha1_hash(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1get_1peers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return ;
  } 
  {
    try {
      (arg1)->dht_get_peers((libtorrent::sha1_hash const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1live_1nodes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return ;
  } 
  {
    try {
      (arg1)->dht_live_nodes((libtorrent::sha1_hash const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1sample_1infohashes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::udp::endpoint *arg2 = 0 ;
  libtorrent::sha1_hash *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::udp::endpoint **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::udp::endpoint const & is null");
    return ;
  } 
  arg3 = *(libtorrent::sha1_hash **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return ;
  } 
  {
    try {
      (arg1)->dht_sample_infohashes((libtorrent::udp::endpoint const &)*arg2,(libtorrent::sha1_hash const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1direct_1request_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::udp::endpoint *arg2 = 0 ;
  libtorrent::entry *arg3 = 0 ;
  libtorrent::client_data_t arg4 ;
  libtorrent::client_data_t *argp4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  (void)jarg4_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::udp::endpoint **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::udp::endpoint const & is null");
    return ;
  } 
  arg3 = *(libtorrent::entry **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry const & is null");
    return ;
  } 
  argp4 = *(libtorrent::client_data_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::client_data_t");
    return ;
  }
  arg4 = *argp4; 
  {
    try {
      (arg1)->dht_direct_request((libtorrent::udp::endpoint const &)*arg2,(libtorrent::entry const &)*arg3,SWIG_STD_MOVE(arg4));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1direct_1request_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::udp::endpoint *arg2 = 0 ;
  libtorrent::entry *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::udp::endpoint **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::udp::endpoint const & is null");
    return ;
  } 
  arg3 = *(libtorrent::entry **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry const & is null");
    return ;
  } 
  {
    try {
      (arg1)->dht_direct_request((libtorrent::udp::endpoint const &)*arg2,(libtorrent::entry const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1set_1ip_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::ip_filter arg2 ;
  libtorrent::ip_filter *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  argp2 = *(libtorrent::ip_filter **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::ip_filter");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      (arg1)->set_ip_filter(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1get_1ip_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::ip_filter result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_handle const *)arg1)->get_ip_filter();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::ip_filter **)&jresult = new libtorrent::ip_filter(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1set_1port_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::port_filter *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::port_filter **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::port_filter const & is null");
    return ;
  } 
  {
    try {
      (arg1)->set_port_filter((libtorrent::port_filter const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1listen_1port(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  unsigned short result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = (unsigned short)((libtorrent::session_handle const *)arg1)->listen_port();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1ssl_1listen_1port(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  unsigned short result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = (unsigned short)((libtorrent::session_handle const *)arg1)->ssl_listen_port();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1is_1listening(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::session_handle const *)arg1)->is_listening();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1set_1peer_1class_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::ip_filter *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::ip_filter **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::ip_filter const & is null");
    return ;
  } 
  {
    try {
      (arg1)->set_peer_class_filter((libtorrent::ip_filter const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1get_1peer_1class_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::ip_filter result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_handle const *)arg1)->get_peer_class_filter();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::ip_filter **)&jresult = new libtorrent::ip_filter(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1set_1peer_1class_1type_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::peer_class_type_filter *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::peer_class_type_filter **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::peer_class_type_filter const & is null");
    return ;
  } 
  {
    try {
      (arg1)->set_peer_class_type_filter((libtorrent::peer_class_type_filter const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1get_1peer_1class_1type_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::peer_class_type_filter result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_handle const *)arg1)->get_peer_class_type_filter();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_class_type_filter **)&jresult = new libtorrent::peer_class_type_filter(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1delete_1files_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::remove_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::remove_flags_tag > *)&libtorrent::session_handle::delete_files;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::remove_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1delete_1partfile_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::remove_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::remove_flags_tag > *)&libtorrent::session_handle::delete_partfile;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::remove_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1paused_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::session_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::session_flags_tag > *)&libtorrent::session_handle::paused;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::session_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1remove_1torrent_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::torrent_handle *arg2 = 0 ;
  libtorrent::remove_flags_t arg3 ;
  libtorrent::remove_flags_t *argp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::torrent_handle **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_handle const & is null");
    return ;
  } 
  argp3 = *(libtorrent::remove_flags_t **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::remove_flags_t");
    return ;
  }
  arg3 = *argp3; 
  {
    try {
      (arg1)->remove_torrent((libtorrent::torrent_handle const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1remove_1torrent_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::torrent_handle *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::torrent_handle **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_handle const & is null");
    return ;
  } 
  {
    try {
      (arg1)->remove_torrent((libtorrent::torrent_handle const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1apply_1settings(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::settings_pack *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::settings_pack **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::settings_pack const & is null");
    return ;
  } 
  {
    try {
      (arg1)->apply_settings((libtorrent::settings_pack const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1get_1settings(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::settings_pack result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_handle const *)arg1)->get_settings();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::settings_pack **)&jresult = new libtorrent::settings_pack(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1pop_1alerts(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  std::vector< libtorrent::alert * > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(std::vector< libtorrent::alert * > **)&jarg2; 
  {
    try {
      (arg1)->pop_alerts(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1udp_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::portmap_protocol result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::portmap_protocol)libtorrent::session_handle::udp;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1tcp_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  enum libtorrent::portmap_protocol result;
  
  (void)jenv;
  (void)jcls;
  result = (enum libtorrent::portmap_protocol)libtorrent::session_handle::tcp;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1reopen_1map_1ports_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned char,libtorrent::reopen_network_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned char,libtorrent::reopen_network_flags_tag > *)&libtorrent::session_handle::reopen_map_ports;
  *(libtorrent::flags::bitfield_flag< unsigned char,libtorrent::reopen_network_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1reopen_1network_1sockets_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::reopen_network_flags_t arg2 ;
  libtorrent::reopen_network_flags_t *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  argp2 = *(libtorrent::reopen_network_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::reopen_network_flags_t");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      (arg1)->reopen_network_sockets(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1reopen_1network_1sockets_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::session_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      (arg1)->reopen_network_sockets();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1get_1item_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  libtorrent::session_handle *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  std::vector< std::int8_t > *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > & is null");
    return ;
  } 
  arg3 = *(std::vector< std::int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > & is null");
    return ;
  } 
  {
    try {
      libtorrent_session_handle_dht_get_item__SWIG_1(arg1,*arg2,*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1get_1item_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  libtorrent::session_handle *arg1 = 0 ;
  std::array< std::int8_t,32 > *arg2 = 0 ;
  std::vector< std::int8_t > *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(std::array< std::int8_t,32 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::array< std::int8_t,32 > & is null");
    return ;
  } 
  arg3 = *(std::vector< std::int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > & is null");
    return ;
  } 
  {
    try {
      libtorrent_session_handle_dht_get_item__SWIG_2(arg1,*arg2,*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1put_1item_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_) {
  libtorrent::session_handle *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  std::vector< std::int8_t > *arg3 = 0 ;
  libtorrent::entry *arg4 = 0 ;
  std::vector< std::int8_t > *arg5 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  (void)jarg4_;
  (void)jarg5_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > & is null");
    return ;
  } 
  arg3 = *(std::vector< std::int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > & is null");
    return ;
  } 
  arg4 = *(libtorrent::entry **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry & is null");
    return ;
  } 
  arg5 = *(std::vector< std::int8_t > **)&jarg5;
  if (!arg5) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > & is null");
    return ;
  } 
  {
    try {
      libtorrent_session_handle_dht_put_item__SWIG_1(arg1,*arg2,*arg3,*arg4,*arg5);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1put_1item_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_) {
  libtorrent::session_handle *arg1 = 0 ;
  std::array< std::int8_t,32 > *arg2 = 0 ;
  std::array< std::int8_t,64 > *arg3 = 0 ;
  libtorrent::entry *arg4 = 0 ;
  std::vector< int8_t > *arg5 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  (void)jarg4_;
  (void)jarg5_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(std::array< std::int8_t,32 > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::array< std::int8_t,32 > & is null");
    return ;
  } 
  arg3 = *(std::array< std::int8_t,64 > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::array< std::int8_t,64 > & is null");
    return ;
  } 
  arg4 = *(libtorrent::entry **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry & is null");
    return ;
  } 
  arg5 = *(std::vector< int8_t > **)&jarg5;
  if (!arg5) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return ;
  } 
  {
    try {
      libtorrent_session_handle_dht_put_item__SWIG_2(arg1,*arg2,*arg3,*arg4,*arg5);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1direct_1request_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::udp::endpoint *arg2 = 0 ;
  libtorrent::entry *arg3 = 0 ;
  int64_t arg4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::udp::endpoint **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::udp::endpoint const & is null");
    return ;
  } 
  arg3 = *(libtorrent::entry **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry const & is null");
    return ;
  } 
  arg4 = (int64_t)jarg4; 
  {
    try {
      libtorrent_session_handle_dht_direct_request__SWIG_2(arg1,(libtorrent::udp::endpoint const &)*arg2,(libtorrent::entry const &)*arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1wait_1for_1alert_1ms(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  std::int64_t arg2 ;
  libtorrent::alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = (std::int64_t)jarg2; 
  {
    try {
      result = (libtorrent::alert *)libtorrent_session_handle_wait_for_alert_ms(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::alert **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1set_1alert_1notify_1callback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  alert_notify_callback *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(alert_notify_callback **)&jarg2; 
  {
    try {
      libtorrent_session_handle_set_alert_notify_callback(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1announce_1ex_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jbyte jarg4) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  int arg3 ;
  std::int8_t arg4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return ;
  } 
  arg3 = (int)jarg3; 
  arg4 = (std::int8_t)jarg4; 
  {
    try {
      libtorrent_session_handle_dht_announce_ex__SWIG_0(arg1,(libtorrent::digest32< 160 > const &)*arg2,arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1announce_1ex_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  int arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return ;
  } 
  arg3 = (int)jarg3; 
  {
    try {
      libtorrent_session_handle_dht_announce_ex__SWIG_0(arg1,(libtorrent::digest32< 160 > const &)*arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1dht_1announce_1ex_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return ;
  } 
  {
    try {
      libtorrent_session_handle_dht_announce_ex__SWIG_0(arg1,(libtorrent::digest32< 160 > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1add_1port_1mapping_1ex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = 0 ;
  libtorrent::portmap_protocol arg2 ;
  int arg3 ;
  int arg4 ;
  std::vector< int > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = (libtorrent::portmap_protocol)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = (int)jarg4; 
  {
    try {
      result = libtorrent_session_handle_add_port_mapping_ex(arg1,arg2,arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int > **)&jresult = new std::vector< int >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1delete_1port_1mapping_1ex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::session_handle *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      libtorrent_session_handle_delete_port_mapping_ex(arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1session_1handle(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::session_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_min_1memory_1usage(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::settings_pack result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::min_memory_usage();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::settings_pack **)&jresult = new libtorrent::settings_pack(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_high_1performance_1seed(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::settings_pack result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::high_performance_seed();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::settings_pack **)&jresult = new libtorrent::settings_pack(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1proxy_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::session_proxy *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::session_proxy *)new libtorrent::session_proxy();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_proxy **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1session_1proxy(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::session_proxy *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::session_proxy **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1proxy_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_proxy *arg1 = 0 ;
  libtorrent::session_proxy *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_proxy **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::session_proxy const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::session_proxy *)new libtorrent::session_proxy((libtorrent::session_proxy const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_proxy **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::session *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::session_params const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::session *)new libtorrent::session((libtorrent::session_params const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = 0 ;
  libtorrent::session_flags_t arg2 ;
  libtorrent::session_flags_t *argp2 ;
  libtorrent::session *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::session_params const & is null");
    return 0;
  } 
  argp2 = *(libtorrent::session_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::session_flags_t");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (libtorrent::session *)new libtorrent::session((libtorrent::session_params const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1_1SWIG_12(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::session *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::session *)new libtorrent::session();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session *arg1 = 0 ;
  std::unique_ptr< libtorrent::session > rvrdeleter1 ;
  libtorrent::session *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::session && is null");
    return 0;
  }
  rvrdeleter1.reset(arg1); 
  {
    try {
      result = (libtorrent::session *)new libtorrent::session((libtorrent::session &&)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1session(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::session *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::session **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1abort(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session *arg1 = 0 ;
  libtorrent::session_proxy result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session **)&jarg1; 
  {
    try {
      result = (arg1)->abort();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::session_proxy **)&jresult = new libtorrent::session_proxy(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1modification_1time_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *)&libtorrent::create_torrent::modification_time;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1symlinks_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *)&libtorrent::create_torrent::symlinks;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1v2_1only_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *)&libtorrent::create_torrent::v2_only;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1v1_1only_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *)&libtorrent::create_torrent::v1_only;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1canonical_1files_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *)&libtorrent::create_torrent::canonical_files;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1no_1attributes_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *)&libtorrent::create_torrent::no_attributes;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1canonical_1files_1no_1tail_1padding_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *)&libtorrent::create_torrent::canonical_files_no_tail_padding;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1allow_1odd_1piece_1size_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > *)&libtorrent::create_torrent::allow_odd_piece_size;
  *(libtorrent::flags::bitfield_flag< unsigned int,libtorrent::create_flags_tag > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1create_1torrent_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  int arg2 ;
  libtorrent::create_flags_t arg3 ;
  libtorrent::create_flags_t *argp3 ;
  libtorrent::create_torrent *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(libtorrent::file_storage **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_storage & is null");
    return 0;
  } 
  arg2 = (int)jarg2; 
  argp3 = *(libtorrent::create_flags_t **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::create_flags_t");
    return 0;
  }
  arg3 = *argp3; 
  {
    try {
      result = (libtorrent::create_torrent *)new libtorrent::create_torrent(*arg1,arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::create_torrent **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1create_1torrent_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  int arg2 ;
  libtorrent::create_torrent *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_storage & is null");
    return 0;
  } 
  arg2 = (int)jarg2; 
  {
    try {
      result = (libtorrent::create_torrent *)new libtorrent::create_torrent(*arg1,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::create_torrent **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1create_1torrent_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  libtorrent::create_torrent *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_storage & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::create_torrent *)new libtorrent::create_torrent(*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::create_torrent **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1create_1torrent_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  libtorrent::create_torrent *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_info const & is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::create_torrent *)new libtorrent::create_torrent((libtorrent::torrent_info const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::create_torrent **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1create_1torrent(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::create_torrent *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1generate(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::create_torrent *arg1 = 0 ;
  libtorrent::entry result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      result = ((libtorrent::create_torrent const *)arg1)->generate();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = new libtorrent::entry(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1files(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::create_torrent *arg1 = 0 ;
  libtorrent::file_storage *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      result = (libtorrent::file_storage *) &((libtorrent::create_torrent const *)arg1)->files();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::file_storage **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1set_1comment(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::create_torrent *arg1 = 0 ;
  char *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return ;
  }
  {
    try {
      (arg1)->set_comment((char const *)arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1set_1creator(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::create_torrent *arg1 = 0 ;
  char *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return ;
  }
  {
    try {
      (arg1)->set_creator((char const *)arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1set_1creation_1date(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::create_torrent *arg1 = 0 ;
  std::time_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  arg2 = (std::time_t)jarg2; 
  {
    try {
      (arg1)->set_creation_date(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1set_1hash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jlong jarg3, jobject jarg3_) {
  libtorrent::create_torrent *arg1 = 0 ;
  piece_index_t arg2 ;
  libtorrent::sha1_hash *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = *(libtorrent::sha1_hash **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return ;
  } 
  {
    try {
      (arg1)->set_hash(SWIG_STD_MOVE(arg2),(libtorrent::sha1_hash const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1add_1node(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::create_torrent *arg1 = 0 ;
  std::pair< std::string,int > arg2 ;
  std::pair< std::string,int > *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  argp2 = *(std::pair< std::string,int > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::pair< std::string,int >");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      (arg1)->add_node(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1set_1priv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::create_torrent *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      (arg1)->set_priv(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1priv(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::create_torrent *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::create_torrent const *)arg1)->priv();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1is_1v2_1only(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::create_torrent *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::create_torrent const *)arg1)->is_v2_only();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1is_1v1_1only(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::create_torrent *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::create_torrent const *)arg1)->is_v1_only();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1num_1pieces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::create_torrent *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::create_torrent const *)arg1)->num_pieces();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1end_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::create_torrent *arg1 = 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      result = ((libtorrent::create_torrent const *)arg1)->end_piece();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1end_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::create_torrent *arg1 = 0 ;
  file_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      result = ((libtorrent::create_torrent const *)arg1)->end_file();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  {
    jresult = static_cast<std::int32_t>(static_cast<std::int32_t>(result));
  }
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1total_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::create_torrent *arg1 = 0 ;
  std::int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      result = (std::int64_t)((libtorrent::create_torrent const *)arg1)->total_size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1piece_1length(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::create_torrent *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::create_torrent const *)arg1)->piece_length();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1piece_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jint jresult = 0 ;
  libtorrent::create_torrent *arg1 = 0 ;
  piece_index_t arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (int)((libtorrent::create_torrent const *)arg1)->piece_size(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1add_1similar_1torrent(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::create_torrent *arg1 = 0 ;
  libtorrent::sha1_hash arg2 ;
  libtorrent::sha1_hash *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  argp2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::sha1_hash");
    return ;
  }
  arg2 = *argp2; 
  {
    try {
      (arg1)->add_similar_torrent(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1add_1url_1seed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::create_torrent *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      libtorrent_create_torrent_add_url_seed(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1add_1http_1seed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::create_torrent *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      libtorrent_create_torrent_add_http_seed(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1add_1tracker_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::create_torrent *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      libtorrent_create_torrent_add_tracker__SWIG_0(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1add_1tracker_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
  libtorrent::create_torrent *arg1 = 0 ;
  std::string *arg2 = 0 ;
  int arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = (int)jarg3; 
  {
    try {
      libtorrent_create_torrent_add_tracker__SWIG_1(arg1,(std::string const &)*arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1add_1collection(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::create_torrent *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      libtorrent_create_torrent_add_collection(arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1set_1root_1cert2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::create_torrent *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_create_torrent_set_root_cert2(arg1,(std::vector< signed char > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1set_1hash2(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jint jarg3, jlong jarg4, jobject jarg4_) {
  libtorrent::create_torrent *arg1 = 0 ;
  file_index_t arg2 ;
  int arg3 ;
  libtorrent::sha256_hash *arg4 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg4_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = (int)jarg3; 
  arg4 = *(libtorrent::sha256_hash **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha256_hash const & is null");
    return ;
  } 
  {
    try {
      libtorrent_create_torrent_set_hash2(arg1,SWIG_STD_MOVE(arg2),arg3,(libtorrent::digest32< 256 > const &)*arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1files_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  libtorrent::file_storage *arg1 = 0 ;
  std::string *arg2 = 0 ;
  libtorrent::create_flags_t arg3 ;
  libtorrent::create_flags_t *argp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(libtorrent::file_storage **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_storage & is null");
    return ;
  } 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  argp3 = *(libtorrent::create_flags_t **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::create_flags_t");
    return ;
  }
  arg3 = *argp3; 
  {
    try {
      libtorrent::add_files(*arg1,(std::string const &)*arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1files_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::file_storage *arg1 = 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_storage & is null");
    return ;
  } 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      libtorrent::add_files(*arg1,(std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1value_1index_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::stats_metric *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::stats_metric **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->value_index = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1value_1index_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::stats_metric *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::stats_metric **)&jarg1; 
  result = (int) ((arg1)->value_index);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1type_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::stats_metric *arg1 = 0 ;
  libtorrent::metric_type_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::stats_metric **)&jarg1; 
  arg2 = (libtorrent::metric_type_t)jarg2; 
  if (arg1) (arg1)->type = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::stats_metric *arg1 = 0 ;
  libtorrent::metric_type_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::stats_metric **)&jarg1; 
  result = (libtorrent::metric_type_t) ((arg1)->type);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1get_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::stats_metric *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::stats_metric **)&jarg1; 
  {
    try {
      result = libtorrent_stats_metric_get_name(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1stats_1metric(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::stats_metric *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::stats_metric *)new libtorrent::stats_metric();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::stats_metric **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1stats_1metric(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::stats_metric *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::stats_metric **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1metrics(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::stats_metric > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::session_stats_metrics();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< libtorrent::stats_metric > **)&jresult = new std::vector< libtorrent::stats_metric >(result); 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_LIBTORRENT_1VERSION_1MAJOR_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)(2);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_LIBTORRENT_1VERSION_1MINOR_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)(0);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_LIBTORRENT_1VERSION_1TINY_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)(11);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_LIBTORRENT_1VERSION_1NUM_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)(((2*10000)+(0*100)+11));
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_LIBTORRENT_1VERSION_1get(JNIEnv *jenv, jclass jcls) {
  jstring jresult = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (char *)(char *)("2.0.11.0");
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_LIBTORRENT_1REVISION_1get(JNIEnv *jenv, jclass jcls) {
  jstring jresult = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (char *)(char *)("6e1587799");
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_version(JNIEnv *jenv, jclass jcls) {
  jstring jresult = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (char *)libtorrent::version();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_make_1magnet_1uri_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::add_torrent_params const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent::make_magnet_uri((libtorrent::add_torrent_params const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_make_1magnet_1uri_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_handle *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_handle const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent::make_magnet_uri((libtorrent::torrent_handle const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_make_1magnet_1uri_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_info *arg1 = 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::torrent_info const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent::make_magnet_uri((libtorrent::torrent_info const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_generate_1fingerprint_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jint jarg3, jint jarg4, jint jarg5) {
  jstring jresult = 0 ;
  std::string arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  int arg5 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = (int)jarg4; 
  arg5 = (int)jarg5; 
  {
    try {
      result = libtorrent::generate_fingerprint(SWIG_STD_MOVE(arg1),arg2,arg3,arg4,arg5);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_generate_1fingerprint_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jint jarg3, jint jarg4) {
  jstring jresult = 0 ;
  std::string arg1 ;
  int arg2 ;
  int arg3 ;
  int arg4 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = (int)jarg4; 
  {
    try {
      result = libtorrent::generate_fingerprint(SWIG_STD_MOVE(arg1),arg2,arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_generate_1fingerprint_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jint jarg3) {
  jstring jresult = 0 ;
  std::string arg1 ;
  int arg2 ;
  int arg3 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      result = libtorrent::generate_fingerprint(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_generate_1fingerprint_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2) {
  jstring jresult = 0 ;
  std::string arg1 ;
  int arg2 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  (&arg1)->assign(arg1_pstr);
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = (int)jarg2; 
  {
    try {
      result = libtorrent::generate_fingerprint(SWIG_STD_MOVE(arg1),arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1resume_1data_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  int arg3 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  arg3 = (int)jarg3; 
  {
    try {
      result = libtorrent::read_resume_data((libtorrent::bdecode_node const &)*arg1,*arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_params **)&jresult = new libtorrent::add_torrent_params(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1resume_1data_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bdecode_node **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent::read_resume_data((libtorrent::bdecode_node const &)*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_params **)&jresult = new libtorrent::add_torrent_params(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1resume_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::entry result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::add_torrent_params const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent::write_resume_data((libtorrent::add_torrent_params const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = new libtorrent::entry(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_allow_1missing_1piece_1layer_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::write_torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::write_torrent_flags_t *)&libtorrent::write_flags::allow_missing_piece_layer;
  *(libtorrent::write_torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_no_1http_1seeds_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::write_torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::write_torrent_flags_t *)&libtorrent::write_flags::no_http_seeds;
  *(libtorrent::write_torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_include_1dht_1nodes_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::write_torrent_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::write_torrent_flags_t *)&libtorrent::write_flags::include_dht_nodes;
  *(libtorrent::write_torrent_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1file_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::entry result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::add_torrent_params const & is null");
    return 0;
  } 
  {
    try {
      result = libtorrent::write_torrent_file((libtorrent::add_torrent_params const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = new libtorrent::entry(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1file_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  libtorrent::write_torrent_flags_t arg2 ;
  libtorrent::write_torrent_flags_t *argp2 ;
  libtorrent::entry result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::add_torrent_params const & is null");
    return 0;
  } 
  argp2 = *(libtorrent::write_torrent_flags_t **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::write_torrent_flags_t");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = libtorrent::write_torrent_file((libtorrent::add_torrent_params const &)*arg1,SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::entry **)&jresult = new libtorrent::entry(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1128_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::bloom_filter< 128 > *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bloom_filter< 128 > **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::bloom_filter< 128 > const *)arg1)->find((libtorrent::sha1_hash const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1128_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::bloom_filter< 128 > *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bloom_filter< 128 > **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return ;
  } 
  {
    try {
      (arg1)->set((libtorrent::sha1_hash const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1128_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::bloom_filter< 128 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bloom_filter< 128 > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jfloat JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1128_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jfloat jresult = 0 ;
  libtorrent::bloom_filter< 128 > *arg1 = 0 ;
  float result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bloom_filter< 128 > **)&jarg1; 
  {
    try {
      result = (float)((libtorrent::bloom_filter< 128 > const *)arg1)->size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jfloat)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bloom_1filter_1128(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::bloom_filter< 128 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::bloom_filter< 128 > *)new libtorrent::bloom_filter< 128 >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bloom_filter< 128 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1128_1to_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::bloom_filter< 128 > *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bloom_filter< 128 > **)&jarg1; 
  {
    try {
      result = libtorrent_bloom_filter_Sl_128_Sg__to_bytes((libtorrent::bloom_filter< 128 > const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1128_1from_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::bloom_filter< 128 > *arg1 = 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bloom_filter< 128 > **)&jarg1; 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_bloom_filter_Sl_128_Sg__from_bytes(arg1,(std::vector< signed char > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bloom_1filter_1128(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::bloom_filter< 128 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::bloom_filter< 128 > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1256_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::bloom_filter< 256 > *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bloom_filter< 256 > **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::bloom_filter< 256 > const *)arg1)->find((libtorrent::sha1_hash const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1256_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::bloom_filter< 256 > *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bloom_filter< 256 > **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & is null");
    return ;
  } 
  {
    try {
      (arg1)->set((libtorrent::sha1_hash const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1256_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::bloom_filter< 256 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bloom_filter< 256 > **)&jarg1; 
  {
    try {
      (arg1)->clear();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jfloat JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1256_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jfloat jresult = 0 ;
  libtorrent::bloom_filter< 256 > *arg1 = 0 ;
  float result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bloom_filter< 256 > **)&jarg1; 
  {
    try {
      result = (float)((libtorrent::bloom_filter< 256 > const *)arg1)->size();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jfloat)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bloom_1filter_1256(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::bloom_filter< 256 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::bloom_filter< 256 > *)new libtorrent::bloom_filter< 256 >();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bloom_filter< 256 > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1256_1to_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::bloom_filter< 256 > *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bloom_filter< 256 > **)&jarg1; 
  {
    try {
      result = libtorrent_bloom_filter_Sl_256_Sg__to_bytes((libtorrent::bloom_filter< 256 > const *)arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bloom_1filter_1256_1from_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::bloom_filter< 256 > *arg1 = 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::bloom_filter< 256 > **)&jarg1; 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & is null");
    return ;
  } 
  {
    try {
      libtorrent_bloom_filter_Sl_256_Sg__from_bytes(arg1,(std::vector< signed char > const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bloom_1filter_1256(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::bloom_filter< 256 > *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::bloom_filter< 256 > **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1peer_1connection_1handle(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  jlong jresult = 0 ;
  std::weak_ptr< peer_connection > arg1 ;
  std::weak_ptr< peer_connection > *argp1 ;
  libtorrent::peer_connection_handle *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  argp1 = *(std::weak_ptr< peer_connection > **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::weak_ptr< peer_connection >");
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (libtorrent::peer_connection_handle *)new libtorrent::peer_connection_handle(SWIG_STD_MOVE(arg1));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_connection_handle **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::connection_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (libtorrent::connection_type)((libtorrent::peer_connection_handle const *)arg1)->type();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1is_1seed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->is_seed();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1upload_1only(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->upload_only();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1pid(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::peer_id *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (libtorrent::peer_id *) &((libtorrent::peer_connection_handle const *)arg1)->pid();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::peer_id **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1has_1piece(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  piece_index_t arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->has_piece(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1is_1interesting(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->is_interesting();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1is_1choked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->is_choked();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1is_1peer_1interested(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->is_peer_interested();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1has_1peer_1choked(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->has_peer_choked();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1choke_1this_1peer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::peer_connection_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      (arg1)->choke_this_peer();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1maybe_1unchoke_1this_1peer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::peer_connection_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      (arg1)->maybe_unchoke_this_peer();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1get_1peer_1info(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::peer_info *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  arg2 = *(libtorrent::peer_info **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::peer_info & is null");
    return ;
  } 
  {
    try {
      ((libtorrent::peer_connection_handle const *)arg1)->get_peer_info(*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1associated_1torrent(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::torrent_handle result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_connection_handle const *)arg1)->associated_torrent();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::torrent_handle **)&jresult = new libtorrent::torrent_handle(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1remote(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::tcp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (libtorrent::tcp::endpoint *) &((libtorrent::peer_connection_handle const *)arg1)->remote();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tcp::endpoint **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1local_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::tcp::endpoint result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_connection_handle const *)arg1)->local_endpoint();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::tcp::endpoint **)&jresult = new libtorrent::tcp::endpoint(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1disconnect_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, int jarg4) {
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  libtorrent::operation_t arg3 ;
  disconnect_severity_t arg4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code const & is null");
    return ;
  } 
  arg3 = (libtorrent::operation_t)jarg3; 
  {
    arg4 = disconnect_severity_t(static_cast<std::uint8_t>(jarg4));
  }
  {
    try {
      (arg1)->disconnect((libtorrent::error_code const &)*arg2,arg3,SWIG_STD_MOVE(arg4));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1disconnect_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3) {
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  libtorrent::operation_t arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code const & is null");
    return ;
  } 
  arg3 = (libtorrent::operation_t)jarg3; 
  {
    try {
      (arg1)->disconnect((libtorrent::error_code const &)*arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1is_1disconnecting(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->is_disconnecting();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1is_1connecting(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->is_connecting();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1is_1outgoing(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->is_outgoing();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1on_1local_1network(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->on_local_network();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1ignore_1unchoke_1slots(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->ignore_unchoke_slots();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1failed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->failed();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1can_1disconnect(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->can_disconnect((libtorrent::error_code const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1has_1metadata(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->has_metadata();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1in_1handshake(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->in_handshake();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1send_1buffer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
  libtorrent::peer_connection_handle *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return ;
  }
  arg3 = (int)jarg3; 
  {
    try {
      (arg1)->send_buffer((char const *)arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1last_1seen_1complete(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  std::time_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::peer_connection_handle const *)arg1)->last_seen_complete();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1op_1eq(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::peer_connection_handle *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  arg2 = *(libtorrent::peer_connection_handle **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::peer_connection_handle const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->operator ==((libtorrent::peer_connection_handle const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1op_1ne(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::peer_connection_handle *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  arg2 = *(libtorrent::peer_connection_handle **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::peer_connection_handle const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->operator !=((libtorrent::peer_connection_handle const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1op_1lt(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  libtorrent::peer_connection_handle *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  arg2 = *(libtorrent::peer_connection_handle **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::peer_connection_handle const & is null");
    return 0;
  } 
  {
    try {
      result = (bool)((libtorrent::peer_connection_handle const *)arg1)->operator <((libtorrent::peer_connection_handle const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connection_1handle_1get_1time_1of_1last_1unchoke(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_connection_handle *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_peer_connection_handle_get_time_of_last_unchoke(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1peer_1connection_1handle(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_connection_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1bt_1peer_1connection_1handle(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  SwigValueWrapper< libtorrent::peer_connection_handle > arg1 ;
  libtorrent::peer_connection_handle *argp1 ;
  libtorrent::bt_peer_connection_handle *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(libtorrent::peer_connection_handle **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::peer_connection_handle");
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (libtorrent::bt_peer_connection_handle *)new libtorrent::bt_peer_connection_handle(SWIG_STD_MOVE(arg1));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::bt_peer_connection_handle **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bt_1peer_1connection_1handle_1packet_1finished(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::bt_peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bt_peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::bt_peer_connection_handle const *)arg1)->packet_finished();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bt_1peer_1connection_1handle_1support_1extensions(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::bt_peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bt_peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::bt_peer_connection_handle const *)arg1)->support_extensions();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bt_1peer_1connection_1handle_1supports_1encryption(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::bt_peer_connection_handle *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::bt_peer_connection_handle **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::bt_peer_connection_handle const *)arg1)->supports_encryption();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1bt_1peer_1connection_1handle(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::bt_peer_connection_handle *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::bt_peer_connection_handle **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1view_1to_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::string_view *arg1 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::string_view **)&jarg1; 
  {
    try {
      result = libtorrent_string_view_to_bytes(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1string_1view(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::string_view *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::string_view *)new libtorrent::string_view();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::string_view **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1view(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::string_view *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::string_view **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ed25519_1create_1seed(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::array< std::int8_t,32 > result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = ed25519_create_seed();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::array< std::int8_t,32 > **)&jresult = new std::array< std::int8_t,32 >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ed25519_1create_1keypair(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  std::pair< std::vector< int8_t >,std::vector< int8_t > > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  {
    try {
      result = ed25519_create_keypair(*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::pair< std::vector< int8_t >,std::vector< int8_t > > **)&jresult = new std::pair< std::vector< int8_t >,std::vector< int8_t > >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ed25519_1sign(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  std::vector< int8_t > *arg3 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  arg3 = *(std::vector< int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  {
    try {
      result = ed25519_sign(*arg1,*arg2,*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ed25519_1verify(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  jboolean jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  std::vector< int8_t > *arg3 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  arg3 = *(std::vector< int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  {
    try {
      result = (bool)ed25519_verify(*arg1,*arg2,*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ed25519_1add_1scalar_1public(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  {
    try {
      result = ed25519_add_scalar_public(*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ed25519_1add_1scalar_1secret(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  {
    try {
      result = ed25519_add_scalar_secret(*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ed25519_1key_1exchange(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & is null");
    return 0;
  } 
  {
    try {
      result = ed25519_key_exchange(*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< int8_t > **)&jresult = new std::vector< int8_t >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1alert_1notify_1callback(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  alert_notify_callback *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(alert_notify_callback **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1notify_1callback_1on_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  alert_notify_callback *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(alert_notify_callback **)&jarg1; 
  {
    try {
      (arg1)->on_alert();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1notify_1callback_1on_1alertSwigExplicitalert_1notify_1callback(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  alert_notify_callback *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(alert_notify_callback **)&jarg1; 
  {
    try {
      (arg1)->alert_notify_callback::on_alert();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1alert_1notify_1callback(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  alert_notify_callback *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (alert_notify_callback *)new SwigDirector_alert_notify_callback(jenv);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(alert_notify_callback **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1notify_1callback_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
  alert_notify_callback *obj = *((alert_notify_callback **)&objarg);
  (void)jcls;
  SwigDirector_alert_notify_callback *director = static_cast<SwigDirector_alert_notify_callback *>(obj);
  director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1notify_1callback_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
  alert_notify_callback *obj = *((alert_notify_callback **)&objarg);
  SwigDirector_alert_notify_callback *director = static_cast<SwigDirector_alert_notify_callback *>(obj);
  (void)jcls;
  if (director) {
    director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1add_1files_1listener(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  add_files_listener *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(add_files_listener **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1files_1listener_1pred(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  add_files_listener *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(add_files_listener **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (bool)(arg1)->pred((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1files_1listener_1predSwigExplicitadd_1files_1listener(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  add_files_listener *arg1 = 0 ;
  std::string *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(add_files_listener **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (bool)(arg1)->add_files_listener::pred((std::string const &)*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1add_1files_1listener(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  add_files_listener *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (add_files_listener *)new SwigDirector_add_files_listener(jenv);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(add_files_listener **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1files_1listener_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
  add_files_listener *obj = *((add_files_listener **)&objarg);
  (void)jcls;
  SwigDirector_add_files_listener *director = static_cast<SwigDirector_add_files_listener *>(obj);
  director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1files_1listener_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
  add_files_listener *obj = *((add_files_listener **)&objarg);
  SwigDirector_add_files_listener *director = static_cast<SwigDirector_add_files_listener *>(obj);
  (void)jcls;
  if (director) {
    director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1files_1ex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {
  libtorrent::file_storage *arg1 = 0 ;
  std::string *arg2 = 0 ;
  add_files_listener *arg3 = 0 ;
  libtorrent::create_flags_t arg4 ;
  libtorrent::create_flags_t *argp4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  (void)jarg4_;
  arg1 = *(libtorrent::file_storage **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_storage & is null");
    return ;
  } 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(add_files_listener **)&jarg3; 
  argp4 = *(libtorrent::create_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::create_flags_t");
    return ;
  }
  arg4 = *argp4; 
  {
    try {
      add_files_ex(*arg1,(std::string const &)*arg2,arg3,SWIG_STD_MOVE(arg4));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1set_1piece_1hashes_1listener(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  set_piece_hashes_listener *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(set_piece_hashes_listener **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_set_1piece_1hashes_1listener_1progress(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  set_piece_hashes_listener *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(set_piece_hashes_listener **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      (arg1)->progress(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_set_1piece_1hashes_1listener_1progressSwigExplicitset_1piece_1hashes_1listener(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  set_piece_hashes_listener *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(set_piece_hashes_listener **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      (arg1)->set_piece_hashes_listener::progress(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1set_1piece_1hashes_1listener(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  set_piece_hashes_listener *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (set_piece_hashes_listener *)new SwigDirector_set_piece_hashes_listener(jenv);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(set_piece_hashes_listener **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_set_1piece_1hashes_1listener_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
  set_piece_hashes_listener *obj = *((set_piece_hashes_listener **)&objarg);
  (void)jcls;
  SwigDirector_set_piece_hashes_listener *director = static_cast<SwigDirector_set_piece_hashes_listener *>(obj);
  director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_set_1piece_1hashes_1listener_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
  set_piece_hashes_listener *obj = *((set_piece_hashes_listener **)&objarg);
  SwigDirector_set_piece_hashes_listener *director = static_cast<SwigDirector_set_piece_hashes_listener *>(obj);
  (void)jcls;
  if (director) {
    director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_set_1piece_1hashes_1ex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {
  libtorrent::create_torrent *arg1 = 0 ;
  std::string *arg2 = 0 ;
  set_piece_hashes_listener *arg3 = 0 ;
  libtorrent::error_code *arg4 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  (void)jarg4_;
  arg1 = *(libtorrent::create_torrent **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::create_torrent & is null");
    return ;
  } 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(set_piece_hashes_listener **)&jarg3; 
  arg4 = *(libtorrent::error_code **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return ;
  } 
  {
    try {
      set_piece_hashes_ex(*arg1,(std::string const &)*arg2,arg3,*arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_set_1piece_1hashes_1posix_1disk_1io(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_) {
  libtorrent::create_torrent *arg1 = 0 ;
  std::string *arg2 = 0 ;
  set_piece_hashes_listener *arg3 = 0 ;
  libtorrent::error_code *arg4 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  (void)jarg4_;
  arg1 = *(libtorrent::create_torrent **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::create_torrent & is null");
    return ;
  } 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(set_piece_hashes_listener **)&jarg3; 
  arg4 = *(libtorrent::error_code **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return ;
  } 
  {
    try {
      set_piece_hashes_posix_disk_io(*arg1,(std::string const &)*arg2,arg3,*arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_boost_1version(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (int)boost_version();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_boost_1lib_1version(JNIEnv *jenv, jclass jcls) {
  jstring jresult = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (char *)boost_lib_version();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_openssl_1version_1number(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (int)openssl_version_number();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_openssl_1version_1text(JNIEnv *jenv, jclass jcls) {
  jstring jresult = 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (char *)openssl_version_text();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_find_1metric_1idx_1s(JNIEnv *jenv, jclass jcls, jstring jarg1) {
  jint jresult = 0 ;
  std::string *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  std::string arg1_str(arg1_pstr);
  arg1 = &arg1_str;
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  {
    try {
      result = (int)find_metric_idx_s((std::string const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1resume_1data_1ex_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  jlong jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  libtorrent::load_torrent_limits *arg3 = 0 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  arg3 = *(libtorrent::load_torrent_limits **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::load_torrent_limits const & is null");
    return 0;
  } 
  {
    try {
      result = read_resume_data_ex((std::vector< signed char > const &)*arg1,*arg2,(libtorrent::load_torrent_limits const &)*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_params **)&jresult = new libtorrent::add_torrent_params(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1resume_1data_1ex_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::vector< std::int8_t > *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< std::int8_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::int8_t > const & is null");
    return 0;
  } 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  {
    try {
      result = read_resume_data_ex((std::vector< signed char > const &)*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_params **)&jresult = new libtorrent::add_torrent_params(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1resume_1data_1buf_1ex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::add_torrent_params const & is null");
    return 0;
  } 
  {
    try {
      result = write_resume_data_buf_ex((libtorrent::add_torrent_params const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = new std::vector< std::int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_write_1torrent_1file_1buf_1ex(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = 0 ;
  std::vector< std::int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::add_torrent_params const & is null");
    return 0;
  } 
  {
    try {
      result = write_torrent_file_buf_ex((libtorrent::add_torrent_params const &)*arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< std::int8_t > **)&jresult = new std::vector< std::int8_t >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_parse_1magnet_1uri(JNIEnv *jenv, jclass jcls, jstring jarg1, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::string *arg1 = 0 ;
  libtorrent::error_code *arg2 = 0 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg2_;
  if(!jarg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg1_pstr = jenv->GetStringUTFChars(jarg1, 0); 
  if (!arg1_pstr) return 0;
  std::string arg1_str(arg1_pstr);
  arg1 = &arg1_str;
  jenv->ReleaseStringUTFChars(jarg1, arg1_pstr); 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & is null");
    return 0;
  } 
  {
    try {
      result = parse_magnet_uri((std::string const &)*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::add_torrent_params **)&jresult = new libtorrent::add_torrent_params(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1interface_1address_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  ip_interface *arg1 = 0 ;
  libtorrent::address *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(ip_interface **)&jarg1; 
  arg2 = *(libtorrent::address **)&jarg2; 
  if (arg1) (arg1)->interface_address = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1interface_1address_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  ip_interface *arg1 = 0 ;
  libtorrent::address *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_interface **)&jarg1; 
  result = (libtorrent::address *)& ((arg1)->interface_address);
  *(libtorrent::address **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1netmask_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  ip_interface *arg1 = 0 ;
  libtorrent::address *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(ip_interface **)&jarg1; 
  arg2 = *(libtorrent::address **)&jarg2; 
  if (arg1) (arg1)->netmask = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1netmask_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  ip_interface *arg1 = 0 ;
  libtorrent::address *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_interface **)&jarg1; 
  result = (libtorrent::address *)& ((arg1)->netmask);
  *(libtorrent::address **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1name_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  ip_interface *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(ip_interface **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2; 
  if (arg1) (arg1)->name = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1name_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  ip_interface *arg1 = 0 ;
  std::vector< std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_interface **)&jarg1; 
  result = (std::vector< std::int8_t > *)& ((arg1)->name);
  *(std::vector< std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1friendly_1name_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  ip_interface *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(ip_interface **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2; 
  if (arg1) (arg1)->friendly_name = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1friendly_1name_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  ip_interface *arg1 = 0 ;
  std::vector< std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_interface **)&jarg1; 
  result = (std::vector< std::int8_t > *)& ((arg1)->friendly_name);
  *(std::vector< std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1description_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  ip_interface *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(ip_interface **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2; 
  if (arg1) (arg1)->description = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1description_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  ip_interface *arg1 = 0 ;
  std::vector< std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_interface **)&jarg1; 
  result = (std::vector< std::int8_t > *)& ((arg1)->description);
  *(std::vector< std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1preferred_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  ip_interface *arg1 = 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_interface **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->preferred = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1preferred_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  ip_interface *arg1 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_interface **)&jarg1; 
  result = (bool) ((arg1)->preferred);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1ip_1interface(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  ip_interface *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (ip_interface *)new ip_interface();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(ip_interface **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1ip_1interface(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  ip_interface *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(ip_interface **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1destination_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  ip_route *arg1 = 0 ;
  libtorrent::address *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(ip_route **)&jarg1; 
  arg2 = *(libtorrent::address **)&jarg2; 
  if (arg1) (arg1)->destination = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1destination_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  ip_route *arg1 = 0 ;
  libtorrent::address *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_route **)&jarg1; 
  result = (libtorrent::address *)& ((arg1)->destination);
  *(libtorrent::address **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1netmask_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  ip_route *arg1 = 0 ;
  libtorrent::address *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(ip_route **)&jarg1; 
  arg2 = *(libtorrent::address **)&jarg2; 
  if (arg1) (arg1)->netmask = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1netmask_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  ip_route *arg1 = 0 ;
  libtorrent::address *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_route **)&jarg1; 
  result = (libtorrent::address *)& ((arg1)->netmask);
  *(libtorrent::address **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1gateway_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  ip_route *arg1 = 0 ;
  libtorrent::address *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(ip_route **)&jarg1; 
  arg2 = *(libtorrent::address **)&jarg2; 
  if (arg1) (arg1)->gateway = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1gateway_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  ip_route *arg1 = 0 ;
  libtorrent::address *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_route **)&jarg1; 
  result = (libtorrent::address *)& ((arg1)->gateway);
  *(libtorrent::address **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1source_1hint_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  ip_route *arg1 = 0 ;
  libtorrent::address *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(ip_route **)&jarg1; 
  arg2 = *(libtorrent::address **)&jarg2; 
  if (arg1) (arg1)->source_hint = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1source_1hint_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  ip_route *arg1 = 0 ;
  libtorrent::address *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_route **)&jarg1; 
  result = (libtorrent::address *)& ((arg1)->source_hint);
  *(libtorrent::address **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1name_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  ip_route *arg1 = 0 ;
  std::vector< std::int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(ip_route **)&jarg1; 
  arg2 = *(std::vector< std::int8_t > **)&jarg2; 
  if (arg1) (arg1)->name = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1name_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  ip_route *arg1 = 0 ;
  std::vector< std::int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_route **)&jarg1; 
  result = (std::vector< std::int8_t > *)& ((arg1)->name);
  *(std::vector< std::int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1mtu_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  ip_route *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_route **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->mtu = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1mtu_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  ip_route *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(ip_route **)&jarg1; 
  result = (int) ((arg1)->mtu);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1ip_1route(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  ip_route *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (ip_route *)new ip_route();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(ip_route **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1ip_1route(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  ip_route *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(ip_route **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_enum_1net_1interfaces(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session *arg1 = 0 ;
  std::vector< ip_interface > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session **)&jarg1; 
  {
    try {
      result = enum_net_interfaces(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_interface > **)&jresult = new std::vector< ip_interface >(result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_enum_1routes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session *arg1 = 0 ;
  std::vector< ip_route > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session **)&jarg1; 
  {
    try {
      result = enum_routes(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(std::vector< ip_route > **)&jresult = new std::vector< ip_route >(result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_mem_1copy(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3) {
  std::vector< std::int8_t > arg1 ;
  char *arg2 = 0 ;
  std::size_t arg3 ;
  std::vector< std::int8_t > *argp1 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(std::vector< std::int8_t > **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::int8_t >");
    return ;
  }
  arg1 = *argp1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return ;
  }
  arg3 = (std::size_t)jarg3; 
  {
    try {
      mem_copy(SWIG_STD_MOVE(arg1),arg2,SWIG_STD_MOVE(arg3));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_copy_1byte_1vector_1to_1char_1array(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3) {
  std::vector< std::int8_t > arg1 ;
  char *arg2 = 0 ;
  unsigned int arg3 ;
  std::vector< std::int8_t > *argp1 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(std::vector< std::int8_t > **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< std::int8_t >");
    return ;
  }
  arg1 = *argp1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return ;
  }
  arg3 = (unsigned int)jarg3; 
  {
    try {
      copy_byte_vector_to_char_array(SWIG_STD_MOVE(arg1),arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_get_1gateway(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  ip_interface *arg1 = 0 ;
  std::vector< ip_route > *arg2 = 0 ;
  libtorrent::address result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(ip_interface **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "ip_interface const & is null");
    return 0;
  } 
  arg2 = *(std::vector< ip_route > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_route > & is null");
    return 0;
  } 
  {
    try {
      result = get_gateway((ip_interface const &)*arg1,*arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(libtorrent::address **)&jresult = new libtorrent::address(result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_device_1for_1address(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  jstring jresult = 0 ;
  libtorrent::session *arg1 = 0 ;
  libtorrent::address arg2 ;
  boost::system::error_code *arg3 = 0 ;
  libtorrent::address *argp2 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session **)&jarg1; 
  argp2 = *(libtorrent::address **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::address");
    return 0;
  }
  arg2 = *argp2; 
  arg3 = *(boost::system::error_code **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "boost::system::error_code & is null");
    return 0;
  } 
  {
    try {
      result = device_for_address(arg1,SWIG_STD_MOVE(arg2),*arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = jenv->NewStringUTF((&result)->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1list_1files_1listener(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  list_files_listener *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(list_files_listener **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_list_1files_1listener_1pred(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  list_files_listener *arg1 = 0 ;
  std::string arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(list_files_listener **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  } 
  const char *arg2_pstr = jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return 0;
  (&arg2)->assign(arg2_pstr);
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      result = (bool)(arg1)->pred(SWIG_STD_MOVE(arg2));
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1list_1files_1listener(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  list_files_listener *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (list_files_listener *)new list_files_listener();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(list_files_listener **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_arm_1neon_1support(JNIEnv *jenv, jclass jcls) {
  jboolean jresult = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (bool)arm_neon_support();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1stat_1t_1size_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  posix_stat_t *arg1 = 0 ;
  int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_stat_t **)&jarg1; 
  arg2 = (int64_t)jarg2; 
  if (arg1) (arg1)->size = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1stat_1t_1size_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  posix_stat_t *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_stat_t **)&jarg1; 
  result = (int64_t) ((arg1)->size);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1stat_1t_1atime_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  posix_stat_t *arg1 = 0 ;
  int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_stat_t **)&jarg1; 
  arg2 = (int64_t)jarg2; 
  if (arg1) (arg1)->atime = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1stat_1t_1atime_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  posix_stat_t *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_stat_t **)&jarg1; 
  result = (int64_t) ((arg1)->atime);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1stat_1t_1mtime_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  posix_stat_t *arg1 = 0 ;
  int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_stat_t **)&jarg1; 
  arg2 = (int64_t)jarg2; 
  if (arg1) (arg1)->mtime = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1stat_1t_1mtime_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  posix_stat_t *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_stat_t **)&jarg1; 
  result = (int64_t) ((arg1)->mtime);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1stat_1t_1ctime_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  posix_stat_t *arg1 = 0 ;
  int64_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_stat_t **)&jarg1; 
  arg2 = (int64_t)jarg2; 
  if (arg1) (arg1)->ctime = arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1stat_1t_1ctime_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  posix_stat_t *arg1 = 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_stat_t **)&jarg1; 
  result = (int64_t) ((arg1)->ctime);
  jresult = (jlong)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1stat_1t_1mode_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  posix_stat_t *arg1 = 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_stat_t **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->mode = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1stat_1t_1mode_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  posix_stat_t *arg1 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_stat_t **)&jarg1; 
  result = (int) ((arg1)->mode);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1posix_1stat_1t(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  posix_stat_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (posix_stat_t *)new posix_stat_t();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(posix_stat_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1posix_1stat_1t(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  posix_stat_t *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(posix_stat_t **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1posix_1wrapper(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  posix_wrapper *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(posix_wrapper **)&jarg1; 
  {
    try {
      delete arg1;
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1open(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4) {
  jint jresult = 0 ;
  posix_wrapper *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_wrapper **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = (int)jarg3; 
  arg4 = (int)jarg4; 
  {
    try {
      result = (int)(arg1)->open((char const *)arg2,arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1openSwigExplicitposix_1wrapper(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3, jint jarg4) {
  jint jresult = 0 ;
  posix_wrapper *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int arg4 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_wrapper **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = (int)jarg3; 
  arg4 = (int)jarg4; 
  {
    try {
      result = (int)(arg1)->posix_wrapper::open((char const *)arg2,arg3,arg4);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1stat(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  jint jresult = 0 ;
  posix_wrapper *arg1 = 0 ;
  char *arg2 = 0 ;
  posix_stat_t *arg3 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(posix_wrapper **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = *(posix_stat_t **)&jarg3; 
  {
    try {
      result = (int)(arg1)->stat((char const *)arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1statSwigExplicitposix_1wrapper(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  jint jresult = 0 ;
  posix_wrapper *arg1 = 0 ;
  char *arg2 = 0 ;
  posix_stat_t *arg3 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(posix_wrapper **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = *(posix_stat_t **)&jarg3; 
  {
    try {
      result = (int)(arg1)->posix_wrapper::stat((char const *)arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1mkdir(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
  jint jresult = 0 ;
  posix_wrapper *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_wrapper **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = (int)jarg3; 
  {
    try {
      result = (int)(arg1)->mkdir((char const *)arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1mkdirSwigExplicitposix_1wrapper(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
  jint jresult = 0 ;
  posix_wrapper *arg1 = 0 ;
  char *arg2 = 0 ;
  int arg3 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_wrapper **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = (int)jarg3; 
  {
    try {
      result = (int)(arg1)->posix_wrapper::mkdir((char const *)arg2,arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1rename(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
  jint jresult = 0 ;
  posix_wrapper *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_wrapper **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = 0;
  if (jarg3) {
    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
    if (!arg3) return 0;
  }
  {
    try {
      result = (int)(arg1)->rename((char const *)arg2,(char const *)arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1renameSwigExplicitposix_1wrapper(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jstring jarg3) {
  jint jresult = 0 ;
  posix_wrapper *arg1 = 0 ;
  char *arg2 = 0 ;
  char *arg3 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_wrapper **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = 0;
  if (jarg3) {
    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
    if (!arg3) return 0;
  }
  {
    try {
      result = (int)(arg1)->posix_wrapper::rename((char const *)arg2,(char const *)arg3);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jint jresult = 0 ;
  posix_wrapper *arg1 = 0 ;
  char *arg2 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_wrapper **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  {
    try {
      result = (int)(arg1)->remove((char const *)arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1removeSwigExplicitposix_1wrapper(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jint jresult = 0 ;
  posix_wrapper *arg1 = 0 ;
  char *arg2 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_wrapper **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  {
    try {
      result = (int)(arg1)->posix_wrapper::remove((char const *)arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  jresult = (jint)result; 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1posix_1wrapper(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  posix_wrapper *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (posix_wrapper *)new SwigDirector_posix_wrapper(jenv);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return 0;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return 0;
    }
  }
  *(posix_wrapper **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
  posix_wrapper *obj = *((posix_wrapper **)&objarg);
  (void)jcls;
  SwigDirector_posix_wrapper *director = static_cast<SwigDirector_posix_wrapper *>(obj);
  director->swig_connect_director(jenv, jself, jenv->GetObjectClass(jself), (jswig_mem_own == JNI_TRUE), (jweak_global == JNI_TRUE));
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_posix_1wrapper_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
  posix_wrapper *obj = *((posix_wrapper **)&objarg);
  SwigDirector_posix_wrapper *director = static_cast<SwigDirector_posix_wrapper *>(obj);
  (void)jcls;
  if (director) {
    director->swig_java_change_ownership(jenv, jself, jtake_or_release ? true : false);
  }
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_set_1posix_1wrapper(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  posix_wrapper *arg1 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(posix_wrapper **)&jarg1; 
  {
    try {
      set_posix_wrapper(arg1);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::torrent_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::peer_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::tracker_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::torrent_removed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_1piece_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::read_piece_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1completed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::file_completed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1renamed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::file_renamed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1rename_1failed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::file_rename_failed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::performance_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1changed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::state_changed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1error_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::tracker_alert **)&baseptr = *(libtorrent::tracker_error_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1warning_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::tracker_alert **)&baseptr = *(libtorrent::tracker_warning_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1reply_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::tracker_alert **)&baseptr = *(libtorrent::scrape_reply_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_scrape_1failed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::tracker_alert **)&baseptr = *(libtorrent::scrape_failed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1reply_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::tracker_alert **)&baseptr = *(libtorrent::tracker_reply_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1reply_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::tracker_alert **)&baseptr = *(libtorrent::dht_reply_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1announce_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::tracker_alert **)&baseptr = *(libtorrent::tracker_announce_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_hash_1failed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::hash_failed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1ban_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::peer_ban_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1unsnubbed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::peer_unsnubbed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1snubbed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::peer_snubbed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1error_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::peer_error_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1connect_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::peer_connect_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1disconnected_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::peer_disconnected_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_invalid_1request_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::invalid_request_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1finished_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::torrent_finished_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1finished_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::piece_finished_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_request_1dropped_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::request_dropped_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1timeout_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::block_timeout_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1finished_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::block_finished_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1downloading_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::block_downloading_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_unwanted_1block_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::unwanted_block_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::storage_moved_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_storage_1moved_1failed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::storage_moved_failed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1deleted_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::torrent_deleted_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::torrent_delete_failed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::save_resume_data_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_save_1resume_1data_1failed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::save_resume_data_failed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1paused_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::torrent_paused_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1resumed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::torrent_resumed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1checked_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::torrent_checked_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_url_1seed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::url_seed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1error_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::file_error_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1failed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::metadata_failed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_metadata_1received_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::metadata_received_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1error_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::udp_error_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_external_1ip_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::external_ip_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1failed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::listen_failed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::listen_succeeded_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::portmap_error_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::portmap_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1log_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::portmap_log_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_fastresume_1rejected_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::fastresume_rejected_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1blocked_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::peer_blocked_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1announce_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_announce_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_get_peers_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_cache_1flushed_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::cache_flushed_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1peer_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::lsd_peer_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_trackerid_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::tracker_alert **)&baseptr = *(libtorrent::trackerid_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1bootstrap_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_bootstrap_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1error_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::torrent_error_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1need_1cert_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::torrent_need_cert_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1connection_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::incoming_connection_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::add_torrent_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_state_1update_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::state_update_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::session_stats_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1error_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_error_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1immutable_1item_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_immutable_item_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1mutable_1item_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_mutable_item_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1put_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_put_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_i2p_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::i2p_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1outgoing_1get_1peers_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_outgoing_get_peers_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_log_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::log_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1log_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::torrent_log_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1log_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::peer_log_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_lsd_1error_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::lsd_error_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1stats_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_stats_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_incoming_1request_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::incoming_request_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1log_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_log_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_pkt_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1get_1peers_1reply_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_get_peers_reply_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1direct_1response_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_direct_response_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_picker_1log_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::picker_log_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1error_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::session_error_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1live_1nodes_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_live_nodes_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1stats_1header_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::session_stats_header_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1sample_1infohashes_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::dht_sample_infohashes_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1uploaded_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_alert **)&baseptr = *(libtorrent::block_uploaded_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alerts_1dropped_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::alerts_dropped_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::alert **)&baseptr = *(libtorrent::socks5_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1prio_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::file_prio_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_oversized_1file_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::oversized_file_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1conflict_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::torrent_conflict_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::peer_info_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1progress_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::file_progress_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1info_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::piece_info_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1availability_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::piece_availability_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tracker_1list_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::tracker_list_alert **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1pack_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::settings_interface **)&baseptr = *(libtorrent::settings_pack **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::session_handle **)&baseptr = *(libtorrent::session **)&jarg1;
    return baseptr;
}

SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bt_1peer_1connection_1handle_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::peer_connection_handle **)&baseptr = *(libtorrent::bt_peer_connection_handle **)&jarg1;
    return baseptr;
}

SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_swig_1module_1init(JNIEnv *jenv, jclass jcls) {
  int i;
  
  static struct {
    const char *method;
    const char *signature;
  } methods[8] = {
    {
      "SwigDirector_alert_notify_callback_on_alert", "(Lcom/frostwire/jlibtorrent/swig/alert_notify_callback;)V" 
    },
    {
      "SwigDirector_add_files_listener_pred", "(Lcom/frostwire/jlibtorrent/swig/add_files_listener;Ljava/lang/String;)Z" 
    },
    {
      "SwigDirector_set_piece_hashes_listener_progress", "(Lcom/frostwire/jlibtorrent/swig/set_piece_hashes_listener;I)V" 
    },
    {
      "SwigDirector_posix_wrapper_open", "(Lcom/frostwire/jlibtorrent/swig/posix_wrapper;Ljava/lang/String;II)I" 
    },
    {
      "SwigDirector_posix_wrapper_stat", "(Lcom/frostwire/jlibtorrent/swig/posix_wrapper;Ljava/lang/String;J)I" 
    },
    {
      "SwigDirector_posix_wrapper_mkdir", "(Lcom/frostwire/jlibtorrent/swig/posix_wrapper;Ljava/lang/String;I)I" 
    },
    {
      "SwigDirector_posix_wrapper_rename", "(Lcom/frostwire/jlibtorrent/swig/posix_wrapper;Ljava/lang/String;Ljava/lang/String;)I" 
    },
    {
      "SwigDirector_posix_wrapper_remove", "(Lcom/frostwire/jlibtorrent/swig/posix_wrapper;Ljava/lang/String;)I" 
    }
  };
  Swig::jclass_libtorrent_jni = (jclass) jenv->NewGlobalRef(jcls);
  if (!Swig::jclass_libtorrent_jni) return;
  for (i = 0; i < (int) (sizeof(methods)/sizeof(methods[0])); ++i) {
    Swig::director_method_ids[i] = jenv->GetStaticMethodID(jcls, methods[i].method, methods[i].signature);
    if (!Swig::director_method_ids[i]) return;
  }
}


#ifdef __cplusplus
}
#endif

