TubeLab-App-Android/frostwire-jlibtorrent/swig/libtorrent_jni.cpp

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 4.0.1
 *
 * This file is not intended to be easily readable and contains a number of
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG
 * interface file instead.
 * ----------------------------------------------------------------------------- */


#ifndef SWIGJAVA
#define SWIGJAVA
#endif

#define SWIG_DIRECTORS


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  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


/* Fix for jlong on some versions of gcc on Windows */
#if defined(__GNUC__) && !defined(__INTEL_COMPILER)
  typedef long long __int64;
#endif

/* Fix for jlong on 64-bit x86 Solaris */
#if defined(__x86_64)
# ifdef _LP64
#   undef _LP64
# endif
#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) if (!(expr)) {SWIG_JavaThrowException(jenv, SWIG_JavaIllegalArgumentException, msg); return nullreturn; } else

/*  Errors in SWIG */
#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

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;
        }
      }
    }

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

  /* 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_(0), 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
      }
      ~JNIEnvWrapper() {
#if !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_;
      }
    };

    /* 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);
        }
      }
    }

  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_(0) {
      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_(0), msg_(0) {

      // 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(0);
                if (classname)
                  classname_ = copypath(classname);
              }
	    }
	  }
	}
      }

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

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

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

    const char *what() const throw() {
      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 = 0;
          }
          if (!throwable)
            jenv->Throw(throwable_);
        } else {
          // Try and reconstruct original exception, but original stacktrace is not reconstructed
          jenv->ExceptionClear();

          jmethodID ctorMethodID = 0;
          jclass throwableclass = 0;
          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 = 0;
      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[9];
  }
}

// BEGIN common set include ------------------------------------------------------

#include "libtorrent/version.hpp"
#include "libtorrent/error_code.hpp"
#include "libtorrent/peer_request.hpp"
#include "libtorrent/file_storage.hpp"
#include "libtorrent/bdecode.hpp"
#include "libtorrent/bencode.hpp"
#include "libtorrent/peer_info.hpp"
#include "libtorrent/torrent_flags.hpp"
#include "libtorrent/torrent_info.hpp"
#include "libtorrent/pex_flags.hpp"
#include "libtorrent/torrent_status.hpp"
#include "libtorrent/torrent_handle.hpp"
#include "libtorrent/add_torrent_params.hpp"
#include "libtorrent/operations.hpp"
#include "libtorrent/session_stats.hpp"
#include "libtorrent/close_reason.hpp"
#include "libtorrent/alert.hpp"
#include "libtorrent/alert_types.hpp"
#include "libtorrent/session_settings.hpp"
#include "libtorrent/settings_pack.hpp"
#include "libtorrent/peer_class.hpp"
#include "libtorrent/peer_class_type_filter.hpp"
#include "libtorrent/session_types.hpp"
#include "libtorrent/ip_filter.hpp"
#include "libtorrent/session_handle.hpp"
#include "libtorrent/kademlia/dht_state.hpp"
#include "libtorrent/kademlia/dht_settings.hpp"
#include "libtorrent/session.hpp"
#include "libtorrent/peer_connection_handle.hpp"
#include "libtorrent/magnet_uri.hpp"
#include "libtorrent/create_torrent.hpp"
#include "libtorrent/fingerprint.hpp"

#include "libtorrent.h"

using piece_index_t = libtorrent::piece_index_t;
using file_index_t = libtorrent::file_index_t;
using peer_class_t = libtorrent::peer_class_t;
using port_mapping_t = libtorrent::port_mapping_t;
using queue_position_t = libtorrent::queue_position_t;
using download_priority_t = libtorrent::download_priority_t;
using disconnect_severity_t = libtorrent::disconnect_severity_t;

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


#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


#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_UnknownError:
  default:
    exception_code = SWIG_JavaUnknownError;
    break;
  }
  SWIG_JavaThrowException(jenv, exception_code, msg);
}


#include <typeinfo>
#include <stdexcept>


#include <utility>

SWIGINTERN int8_t std_vector_Sl_int8_t_Sg__get(std::vector< int8_t > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_int8_t_Sg__set(std::vector< int8_t > *self,int i,std::vector< signed char >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< std::string >::const_reference std_vector_Sl_std_string_Sg__get(std::vector< std::string > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_std_string_Sg__set(std::vector< std::string > *self,int i,std::vector< std::string >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< std::pair< std::string,int > >::const_reference std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__get(std::vector< std::pair< std::string,int > > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                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__set(std::vector< std::pair< std::string,int > > *self,int i,std::vector< std::pair< std::string,int > >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< std::pair< std::string,std::string > >::const_reference std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__get(std::vector< std::pair< std::string,std::string > > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                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__set(std::vector< std::pair< std::string,std::string > > *self,int i,std::vector< std::pair< std::string,std::string > >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< std::pair< piece_index_t,int > >::const_reference std_vector_Sl_std_pair_Sl_piece_index_t_Sc_int_Sg__Sg__get(std::vector< std::pair< piece_index_t,int > > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_std_pair_Sl_piece_index_t_Sc_int_Sg__Sg__set(std::vector< std::pair< piece_index_t,int > > *self,int i,std::vector< std::pair< piece_index_t,int > >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< int >::const_reference std_vector_Sl_int_Sg__get(std::vector< int > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_int_Sg__set(std::vector< int > *self,int i,std::vector< int >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< long long >::const_reference std_vector_Sl_long_SS_long_Sg__get(std::vector< long long > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_long_SS_long_Sg__set(std::vector< long long > *self,int i,std::vector< long long >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::sha1_hash >::const_reference std_vector_Sl_libtorrent_sha1_hash_Sg__get(std::vector< libtorrent::sha1_hash > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_sha1_hash_Sg__set(std::vector< libtorrent::sha1_hash > *self,int i,std::vector< libtorrent::sha1_hash >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::torrent_status >::const_reference std_vector_Sl_libtorrent_torrent_status_Sg__get(std::vector< libtorrent::torrent_status > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_torrent_status_Sg__set(std::vector< libtorrent::torrent_status > *self,int i,std::vector< libtorrent::torrent_status >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::torrent_handle >::const_reference std_vector_Sl_libtorrent_torrent_handle_Sg__get(std::vector< libtorrent::torrent_handle > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_torrent_handle_Sg__set(std::vector< libtorrent::torrent_handle > *self,int i,std::vector< libtorrent::torrent_handle >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::file_slice >::const_reference std_vector_Sl_libtorrent_file_slice_Sg__get(std::vector< libtorrent::file_slice > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_file_slice_Sg__set(std::vector< libtorrent::file_slice > *self,int i,std::vector< libtorrent::file_slice >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::dht_routing_bucket >::const_reference std_vector_Sl_libtorrent_dht_routing_bucket_Sg__get(std::vector< libtorrent::dht_routing_bucket > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_dht_routing_bucket_Sg__set(std::vector< libtorrent::dht_routing_bucket > *self,int i,std::vector< libtorrent::dht_routing_bucket >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::dht_lookup >::const_reference std_vector_Sl_libtorrent_dht_lookup_Sg__get(std::vector< libtorrent::dht_lookup > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_dht_lookup_Sg__set(std::vector< libtorrent::dht_lookup > *self,int i,std::vector< libtorrent::dht_lookup >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::block_info >::const_reference std_vector_Sl_libtorrent_block_info_Sg__get(std::vector< libtorrent::block_info > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_block_info_Sg__set(std::vector< libtorrent::block_info > *self,int i,std::vector< libtorrent::block_info >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::partial_piece_info >::const_reference std_vector_Sl_libtorrent_partial_piece_info_Sg__get(std::vector< libtorrent::partial_piece_info > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_partial_piece_info_Sg__set(std::vector< libtorrent::partial_piece_info > *self,int i,std::vector< libtorrent::partial_piece_info >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::peer_info >::const_reference std_vector_Sl_libtorrent_peer_info_Sg__get(std::vector< libtorrent::peer_info > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_peer_info_Sg__set(std::vector< libtorrent::peer_info > *self,int i,std::vector< libtorrent::peer_info >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::stats_metric >::const_reference std_vector_Sl_libtorrent_stats_metric_Sg__get(std::vector< libtorrent::stats_metric > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_stats_metric_Sg__set(std::vector< libtorrent::stats_metric > *self,int i,std::vector< libtorrent::stats_metric >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::entry >::const_reference std_vector_Sl_libtorrent_entry_Sg__get(std::vector< libtorrent::entry > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_entry_Sg__set(std::vector< libtorrent::entry > *self,int i,std::vector< libtorrent::entry >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::web_seed_entry >::const_reference std_vector_Sl_libtorrent_web_seed_entry_Sg__get(std::vector< libtorrent::web_seed_entry > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_web_seed_entry_Sg__set(std::vector< libtorrent::web_seed_entry > *self,int i,std::vector< libtorrent::web_seed_entry >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::announce_endpoint >::const_reference std_vector_Sl_libtorrent_announce_endpoint_Sg__get(std::vector< libtorrent::announce_endpoint > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_announce_endpoint_Sg__set(std::vector< libtorrent::announce_endpoint > *self,int i,std::vector< libtorrent::announce_endpoint >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::announce_entry >::const_reference std_vector_Sl_libtorrent_announce_entry_Sg__get(std::vector< libtorrent::announce_entry > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_announce_entry_Sg__set(std::vector< libtorrent::announce_entry > *self,int i,std::vector< libtorrent::announce_entry >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::tcp::endpoint >::const_reference std_vector_Sl_libtorrent_tcp_endpoint_Sg__get(std::vector< libtorrent::tcp::endpoint > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_tcp_endpoint_Sg__set(std::vector< libtorrent::tcp::endpoint > *self,int i,std::vector< libtorrent::tcp::endpoint >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< libtorrent::udp::endpoint >::const_reference std_vector_Sl_libtorrent_udp_endpoint_Sg__get(std::vector< libtorrent::udp::endpoint > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_udp_endpoint_Sg__set(std::vector< libtorrent::udp::endpoint > *self,int i,std::vector< libtorrent::udp::endpoint >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< piece_index_t >::const_reference std_vector_Sl_piece_index_t_Sg__get(std::vector< piece_index_t > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_piece_index_t_Sg__set(std::vector< piece_index_t > *self,int i,std::vector< piece_index_t >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< file_index_t >::const_reference std_vector_Sl_file_index_t_Sg__get(std::vector< file_index_t > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_file_index_t_Sg__set(std::vector< file_index_t > *self,int i,std::vector< file_index_t >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::const_reference std_vector_Sl_std_pair_Sl_libtorrent_sha1_hash_Sc_libtorrent_udp_endpoint_Sg__Sg__get(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_sha1_hash_Sc_libtorrent_udp_endpoint_Sg__Sg__set(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *self,int i,std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::const_reference std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_sha1_hash_Sg__Sg__get(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_sha1_hash_Sg__Sg__set(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *self,int i,std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::string const &std_map_Sl_file_index_t_Sc_std_string_Sg__get(std::map< file_index_t,std::string > *self,file_index_t const &key){
                std::map<file_index_t,std::string >::iterator i = self->find(key);
                if (i != self->end())
                    return i->second;
                else
                    throw std::out_of_range("key not found");
            }
SWIGINTERN void std_map_Sl_file_index_t_Sc_std_string_Sg__set(std::map< file_index_t,std::string > *self,file_index_t const &key,std::string const &x){
                (*self)[key] = x;
            }
SWIGINTERN void std_map_Sl_file_index_t_Sc_std_string_Sg__erase(std::map< file_index_t,std::string > *self,file_index_t const &key){
                std::map<file_index_t,std::string >::iterator i = self->find(key);
                if (i != self->end())
                    self->erase(i);
                else
                    throw std::out_of_range("key not found");
            }
SWIGINTERN bool std_map_Sl_file_index_t_Sc_std_string_Sg__has_key(std::map< file_index_t,std::string > *self,file_index_t const &key){
                std::map<file_index_t,std::string >::iterator i = self->find(key);
                return i != self->end();
            }
SWIGINTERN std::vector< file_index_t > std_map_Sl_file_index_t_Sc_std_string_Sg__keys(std::map< file_index_t,std::string > *self){
                std::vector<file_index_t> v;
                for(std::map<file_index_t, std::string>::iterator it = self->begin(),
                    end(self->end()); it != end; ++it) {
                    v.push_back(it->first);
                }
                return v;
            }
SWIGINTERN long const &std_map_Sl_std_string_Sc_long_Sg__get(std::map< std::string,long > *self,std::string const &key){
                std::map<std::string,long >::iterator i = self->find(key);
                if (i != self->end())
                    return i->second;
                else
                    throw std::out_of_range("key not found");
            }
SWIGINTERN void std_map_Sl_std_string_Sc_long_Sg__set(std::map< std::string,long > *self,std::string const &key,long const &x){
                (*self)[key] = x;
            }
SWIGINTERN void std_map_Sl_std_string_Sc_long_Sg__erase(std::map< std::string,long > *self,std::string const &key){
                std::map<std::string,long >::iterator i = self->find(key);
                if (i != self->end())
                    self->erase(i);
                else
                    throw std::out_of_range("key not found");
            }
SWIGINTERN bool std_map_Sl_std_string_Sc_long_Sg__has_key(std::map< std::string,long > *self,std::string const &key){
                std::map<std::string,long >::iterator i = self->find(key);
                return i != self->end();
            }
SWIGINTERN std::vector< std::string > std_map_Sl_std_string_Sc_long_Sg__keys(std::map< std::string,long > *self){
                std::vector<std::string> v;
                for(std::map<std::string, long>::iterator it = self->begin(),
                    end(self->end()); it != end; ++it) {
                    v.push_back(it->first);
                }
                return v;
            }
SWIGINTERN libtorrent::entry const &std_map_Sl_std_string_Sc_libtorrent_entry_Sg__get(std::map< std::string,libtorrent::entry > *self,std::string const &key){
                std::map<std::string,libtorrent::entry >::iterator i = self->find(key);
                if (i != self->end())
                    return i->second;
                else
                    throw std::out_of_range("key not found");
            }
SWIGINTERN void std_map_Sl_std_string_Sc_libtorrent_entry_Sg__set(std::map< std::string,libtorrent::entry > *self,std::string const &key,libtorrent::entry const &x){
                (*self)[key] = x;
            }
SWIGINTERN void std_map_Sl_std_string_Sc_libtorrent_entry_Sg__erase(std::map< std::string,libtorrent::entry > *self,std::string const &key){
                std::map<std::string,libtorrent::entry >::iterator i = self->find(key);
                if (i != self->end())
                    self->erase(i);
                else
                    throw std::out_of_range("key not found");
            }
SWIGINTERN bool std_map_Sl_std_string_Sc_libtorrent_entry_Sg__has_key(std::map< std::string,libtorrent::entry > *self,std::string const &key){
                std::map<std::string,libtorrent::entry >::iterator i = self->find(key);
                return i != self->end();
            }
SWIGINTERN std::vector< std::string > std_map_Sl_std_string_Sc_libtorrent_entry_Sg__keys(std::map< std::string,libtorrent::entry > *self){
                std::vector<std::string> v;
                for(std::map<std::string, libtorrent::entry>::iterator it = self->begin(),
                    end(self->end()); it != end; ++it) {
                    v.push_back(it->first);
                }
                return v;
            }
SWIGINTERN std::vector< libtorrent::alert * >::const_reference std_vector_Sl_libtorrent_alert_Sm__Sg__get(std::vector< libtorrent::alert * > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_libtorrent_alert_Sm__Sg__set(std::vector< libtorrent::alert * > *self,int i,std::vector< libtorrent::alert * >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< ip_interface >::const_reference std_vector_Sl_ip_interface_Sg__get(std::vector< ip_interface > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_ip_interface_Sg__set(std::vector< ip_interface > *self,int i,std::vector< ip_interface >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< ip_route >::const_reference std_vector_Sl_ip_route_Sg__get(std::vector< ip_route > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_ip_route_Sg__set(std::vector< ip_route > *self,int i,std::vector< ip_route >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN std::vector< port_mapping_t >::const_reference std_vector_Sl_port_mapping_t_Sg__get(std::vector< port_mapping_t > *self,int i){
                int size = int(self->size());
                if (i>=0 && i<size)
                    return (*self)[i];
                else
                    throw std::out_of_range("vector index out of range");
            }
SWIGINTERN void std_vector_Sl_port_mapping_t_Sg__set(std::vector< port_mapping_t > *self,int i,std::vector< port_mapping_t >::value_type const &val){
                int size = int(self->size());
                if (i>=0 && i<size)
                    (*self)[i] = val;
                else
                    throw std::out_of_range("vector index out of range");
            }
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_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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 libtorrent::sha1_hash *new_libtorrent_sha1_hash__SWIG_2(std::vector< int8_t > const &s){
                return new libtorrent::sha1_hash({reinterpret_cast<char const*>(s.data()), static_cast<long>(s.size())});
            }
SWIGINTERN int libtorrent_sha1_hash_hash_code(libtorrent::sha1_hash *self){
                char const* data = self->data();
                int result = 1;
                for (int i = 0; i < int(self->size()); i++) {
                    result = 31 * result + data[i];
                }
                return result;
            }
SWIGINTERN std::vector< int8_t > libtorrent_sha1_hash_to_bytes(libtorrent::sha1_hash *self){
                std::string s = self->to_string();
                return std::vector<int8_t>(s.begin(), s.end());
            }
SWIGINTERN std::string libtorrent_sha1_hash_to_hex(libtorrent::sha1_hash *self){
                return libtorrent::aux::to_hex(*self);
            }
SWIGINTERN bool libtorrent_sha1_hash_op_eq(libtorrent::sha1_hash const *self,libtorrent::sha1_hash const &n){
                return *self == n;
            }
SWIGINTERN bool libtorrent_sha1_hash_op_ne(libtorrent::sha1_hash const *self,libtorrent::sha1_hash const &n){
                return *self != n;
            }
SWIGINTERN bool libtorrent_sha1_hash_op_lt(libtorrent::sha1_hash const *self,libtorrent::sha1_hash const &n){
                return *self < n;
            }
SWIGINTERN int libtorrent_sha1_hash_compare(libtorrent::sha1_hash const &h1,libtorrent::sha1_hash const &h2){
                return h1 == h2 ? 0 : (h1 < h2 ? -1 : 1);
            }
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 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());
            }
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 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 std::vector< int8_t > libtorrent_announce_endpoint_get_message(libtorrent::announce_endpoint *self){
                std::string s = self->message;
                return {s.begin(), s.end()};
            }
SWIGINTERN int64_t libtorrent_announce_endpoint_get_next_announce(libtorrent::announce_endpoint *self){
                return libtorrent::total_milliseconds(self->next_announce.time_since_epoch());
            }
SWIGINTERN int64_t libtorrent_announce_endpoint_get_min_announce(libtorrent::announce_endpoint *self){
                return libtorrent::total_milliseconds(self->min_announce.time_since_epoch());
            }
SWIGINTERN libtorrent::announce_entry *new_libtorrent_announce_entry(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__SWIG_4(libtorrent::file_storage *self,std::string const &path,std::int64_t file_size,libtorrent::file_flags_t file_flags,std::time_t mtime,std::string const &symlink_path){
        self->add_file(path, file_size, file_flags, mtime, symlink_path);
    }
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_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 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::torrent_info *new_libtorrent_torrent_info__SWIG_4(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::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 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 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 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 void libtorrent_add_torrent_params_set_renamed_files(libtorrent::add_torrent_params *self,std::map< file_index_t,std::string > const &renamed_files){
        self->renamed_files = renamed_files;
    }
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 void libtorrent_add_torrent_params_set_merkle_tree(libtorrent::add_torrent_params *self,std::vector< libtorrent::sha1_hash > const &merkle_tree){
        self->merkle_tree = merkle_tree;
    }
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 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 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 libtorrent::add_torrent_params libtorrent_add_torrent_params_create_instance(){
        return libtorrent::add_torrent_params();
    }
SWIGINTERN libtorrent::add_torrent_params libtorrent_add_torrent_params_create_instance_disabled_storage(){
        return libtorrent::add_torrent_params(libtorrent::disabled_storage_constructor);
    }
SWIGINTERN libtorrent::add_torrent_params libtorrent_add_torrent_params_create_instance_zero_storage(){
        return libtorrent::add_torrent_params(libtorrent::zero_storage_constructor);
    }
SWIGINTERN void libtorrent_add_torrent_params_set_default_storage(libtorrent::add_torrent_params *self){
        self->storage = libtorrent::default_storage_constructor;
    }
SWIGINTERN void libtorrent_add_torrent_params_set_disabled_storage(libtorrent::add_torrent_params *self){
        self->storage = libtorrent::disabled_storage_constructor;
    }
SWIGINTERN void libtorrent_add_torrent_params_set_zero_storage(libtorrent::add_torrent_params *self){
        self->storage = libtorrent::zero_storage_constructor;
    }
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);
    }
SWIGINTERN std::string libtorrent_stats_metric_get_name(libtorrent::stats_metric *self){
        return std::string(self->name);
    }
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::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::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_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::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::performance_alert const *libtorrent_alert_cast_to_performance_alert(libtorrent::alert const *a){          return libtorrent::alert_cast<libtorrent::performance_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::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_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::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::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::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::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::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::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::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_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::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_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_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::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::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::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::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::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_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_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::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::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_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_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::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::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_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::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::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::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::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::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::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::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::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_alert const *libtorrent_alert_cast_to_portmap_alert(libtorrent::alert const *a){          return libtorrent::alert_cast<libtorrent::portmap_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::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::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::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_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::stats_alert const *libtorrent_alert_cast_to_stats_alert(libtorrent::alert const *a){          return libtorrent::alert_cast<libtorrent::stats_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::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::trackerid_alert const *libtorrent_alert_cast_to_trackerid_alert(libtorrent::alert const *a){          return libtorrent::alert_cast<libtorrent::trackerid_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::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_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::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::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::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::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::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_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_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_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::i2p_alert const *libtorrent_alert_cast_to_i2p_alert(libtorrent::alert const *a){          return libtorrent::alert_cast<libtorrent::i2p_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::log_alert const *libtorrent_alert_cast_to_log_alert(libtorrent::alert const *a){          return libtorrent::alert_cast<libtorrent::log_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::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::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::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::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::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_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_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_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::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::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::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::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::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::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::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 int64_t libtorrent_alert_get_timestamp(libtorrent::alert *self){
        return libtorrent::total_milliseconds(self->timestamp().time_since_epoch());
    }
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 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 libtorrent::address libtorrent_dht_announce_alert_get_ip(libtorrent::dht_announce_alert *self){
        return self->ip;
    }
SWIGINTERN int libtorrent_stats_alert_get_transferred(libtorrent::stats_alert *self,int index){
        return self->transferred[index];
    }
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::vector< int8_t > libtorrent_dht_put_alert_get_public_key(libtorrent::dht_put_alert *self){
        std::array<char, 32> arr = self->public_key;
        return std::vector<int8_t>(arr.begin(), arr.end());
    }
SWIGINTERN std::vector< int8_t > libtorrent_dht_put_alert_get_signature(libtorrent::dht_put_alert *self){
        std::array<char, 64> arr = self->signature;
        return std::vector<int8_t>(arr.begin(), arr.end());
    }
SWIGINTERN std::vector< int8_t > libtorrent_dht_put_alert_get_salt(libtorrent::dht_put_alert *self){
        std::string s = self->salt;
        return std::vector<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_pkt_alert_get_node(libtorrent::dht_pkt_alert *self){
        return self->node;
    }
SWIGINTERN int64_t libtorrent_dht_direct_response_alert_get_userdata(libtorrent::dht_direct_response_alert *self){
        return (int64_t)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 void libtorrent_session_handle_dht_get_item__SWIG_1(libtorrent::session_handle *self,std::vector< int8_t > &key,std::vector< 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_put_item__SWIG_1(libtorrent::session_handle *self,std::vector< int8_t > &key,std::vector< int8_t > &sk,libtorrent::entry &data,std::vector< 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_direct_request__SWIG_1(libtorrent::session_handle *self,libtorrent::udp::endpoint const &ep,libtorrent::entry const &e,int64_t userdata){
        self->dht_direct_request(ep, e, (void*)userdata);
    }
SWIGINTERN libtorrent::alert *libtorrent_session_handle_wait_for_alert_ms(libtorrent::session_handle *self,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_add_extension(libtorrent::session_handle *self,swig_plugin *ext){
        self->add_extension(std::shared_ptr<libtorrent::plugin>(ext));
    }
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 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(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< int8_t > const &pem){
        std::string s{pem.begin(), pem.end()};
        self->set_root_cert(s);
    }


/* ---------------------------------------------------
 * 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 struct {
    const char *mname;
    const char *mdesc;
    jmethodID base_methid;
  } methods[] = {
    {
      "on_alert", "()V", NULL 
    }
  };
  
  static jclass baseclass = 0 ;
  
  if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
    if (!baseclass) {
      baseclass = jenv->FindClass("com/frostwire/jlibtorrent/swig/alert_notify_callback");
      if (!baseclass) return;
      baseclass = (jclass) jenv->NewGlobalRef(baseclass);
    }
    bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
    for (int i = 0; i < 1; ++i) {
      if (!methods[i].base_methid) {
        methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
        if (!methods[i].base_methid) return;
      }
      swig_override[i] = false;
      if (derived) {
        jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
        swig_override[i] = (methid != methods[i].base_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 struct {
    const char *mname;
    const char *mdesc;
    jmethodID base_methid;
  } methods[] = {
    {
      "pred", "(Ljava/lang/String;)Z", NULL 
    }
  };
  
  static jclass baseclass = 0 ;
  
  if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
    if (!baseclass) {
      baseclass = jenv->FindClass("com/frostwire/jlibtorrent/swig/add_files_listener");
      if (!baseclass) return;
      baseclass = (jclass) jenv->NewGlobalRef(baseclass);
    }
    bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
    for (int i = 0; i < 1; ++i) {
      if (!methods[i].base_methid) {
        methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
        if (!methods[i].base_methid) return;
      }
      swig_override[i] = false;
      if (derived) {
        jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
        swig_override[i] = (methid != methods[i].base_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 struct {
    const char *mname;
    const char *mdesc;
    jmethodID base_methid;
  } methods[] = {
    {
      "progress", "(I)V", NULL 
    }
  };
  
  static jclass baseclass = 0 ;
  
  if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
    if (!baseclass) {
      baseclass = jenv->FindClass("com/frostwire/jlibtorrent/swig/set_piece_hashes_listener");
      if (!baseclass) return;
      baseclass = (jclass) jenv->NewGlobalRef(baseclass);
    }
    bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
    for (int i = 0; i < 1; ++i) {
      if (!methods[i].base_methid) {
        methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
        if (!methods[i].base_methid) return;
      }
      swig_override[i] = false;
      if (derived) {
        jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
        swig_override[i] = (methid != methods[i].base_methid);
        jenv->ExceptionClear();
      }
    }
  }
}


SwigDirector_swig_plugin::SwigDirector_swig_plugin(JNIEnv *jenv) : swig_plugin(), Swig::Director(jenv) {
}

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


bool SwigDirector_swig_plugin::on_dht_request(libtorrent::string_view query, libtorrent::udp::endpoint const &source, libtorrent::bdecode_node const &message, libtorrent::entry &response) {
  bool c_result = SwigValueInit< bool >() ;
  jboolean jresult = 0 ;
  JNIEnvWrapper swigjnienv(this) ;
  JNIEnv * jenv = swigjnienv.getJNIEnv() ;
  jobject swigjobj = (jobject) NULL ;
  jlong jquery  ;
  jlong jsource = 0 ;
  jlong jmessage = 0 ;
  jlong jresponse = 0 ;
  
  if (!swig_override[0]) {
    return swig_plugin::on_dht_request(query,source,message,response);
  }
  swigjobj = swig_get_self(jenv);
  if (swigjobj && jenv->IsSameObject(swigjobj, NULL) == JNI_FALSE) {
    jquery = 0;
    *((libtorrent::string_view **)&jquery) = new libtorrent::string_view((const libtorrent::string_view &)query); 
    *(libtorrent::udp::endpoint **)&jsource = (libtorrent::udp::endpoint *) &source; 
    *(libtorrent::bdecode_node **)&jmessage = (libtorrent::bdecode_node *) &message; 
    *(libtorrent::entry **)&jresponse = (libtorrent::entry *) &response; 
    jresult = (jboolean) jenv->CallStaticBooleanMethod(Swig::jclass_libtorrent_jni, Swig::director_method_ids[3], swigjobj, jquery, jsource, jmessage, jresponse);
    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 swig_plugin::on_dht_request ");
  }
  if (swigjobj) jenv->DeleteLocalRef(swigjobj);
  return c_result;
}

void SwigDirector_swig_plugin::swig_connect_director(JNIEnv *jenv, jobject jself, jclass jcls, bool swig_mem_own, bool weak_global) {
  static struct {
    const char *mname;
    const char *mdesc;
    jmethodID base_methid;
  } methods[] = {
    {
      "on_dht_request", "(Lcom/frostwire/jlibtorrent/swig/string_view;Lcom/frostwire/jlibtorrent/swig/udp_endpoint;Lcom/frostwire/jlibtorrent/swig/bdecode_node;Lcom/frostwire/jlibtorrent/swig/entry;)Z", NULL 
    }
  };
  
  static jclass baseclass = 0 ;
  
  if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
    if (!baseclass) {
      baseclass = jenv->FindClass("com/frostwire/jlibtorrent/swig/swig_plugin");
      if (!baseclass) return;
      baseclass = (jclass) jenv->NewGlobalRef(baseclass);
    }
    bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
    for (int i = 0; i < 1; ++i) {
      if (!methods[i].base_methid) {
        methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
        if (!methods[i].base_methid) return;
      }
      swig_override[i] = false;
      if (derived) {
        jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
        swig_override[i] = (methid != methods[i].base_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[4], 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[5], 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[6], 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[7], 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[8], 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 struct {
    const char *mname;
    const char *mdesc;
    jmethodID base_methid;
  } methods[] = {
    {
      "open", "(Ljava/lang/String;II)I", NULL 
    },
    {
      "stat", "(Ljava/lang/String;Lcom/frostwire/jlibtorrent/swig/posix_stat_t;)I", NULL 
    },
    {
      "mkdir", "(Ljava/lang/String;I)I", NULL 
    },
    {
      "rename", "(Ljava/lang/String;Ljava/lang/String;)I", NULL 
    },
    {
      "remove", "(Ljava/lang/String;)I", NULL 
    }
  };
  
  static jclass baseclass = 0 ;
  
  if (swig_set_self(jenv, jself, swig_mem_own, weak_global)) {
    if (!baseclass) {
      baseclass = jenv->FindClass("com/frostwire/jlibtorrent/swig/posix_wrapper");
      if (!baseclass) return;
      baseclass = (jclass) jenv->NewGlobalRef(baseclass);
    }
    bool derived = (jenv->IsSameObject(baseclass, jcls) ? false : true);
    for (int i = 0; i < 5; ++i) {
      if (!methods[i].base_methid) {
        methods[i].base_methid = jenv->GetMethodID(baseclass, methods[i].mname, methods[i].mdesc);
        if (!methods[i].base_methid) return;
      }
      swig_override[i] = false;
      if (derived) {
        jmethodID methid = jenv->GetMethodID(jcls, methods[i].mname, methods[i].mdesc);
        swig_override[i] = (methid != methods[i].base_methid);
        jenv->ExceptionClear();
      }
    }
  }
}



#ifdef __cplusplus
extern "C" {
#endif

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 >(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 & reference 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 = (std::pair< piece_index_t,int > *) 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 = (std::pair< piece_index_t,int > *) 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 = (std::pair< piece_index_t,int > *) 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 = (std::pair< piece_index_t,int > *) 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 = (std::pair< piece_index_t,int > *) 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_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 = (const char *)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 >(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 & reference 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 = (std::pair< std::string,int > *) 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 = (const char *)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 = (std::pair< std::string,int > *) 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 = (std::pair< std::string,int > *) 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 = (std::pair< std::string,int > *) 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 = (std::pair< std::string,int > *) 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 = (const char *)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 = (const char *)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 >(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,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 & reference 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 = (std::pair< std::string,std::string > *) 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 = (const char *)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 = (std::pair< std::string,std::string > *) 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 = (std::pair< std::string,std::string > *) 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 = (const char *)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 = (std::pair< std::string,std::string > *) 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 = (std::pair< std::string,std::string > *) 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_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 >(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< 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 & reference 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 = (std::pair< libtorrent::string_view,libtorrent::bdecode_node > *) 0 ;
  libtorrent::string_view *arg2 = (libtorrent::string_view *) 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 = (std::pair< libtorrent::string_view,libtorrent::bdecode_node > *) 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 = (std::pair< libtorrent::string_view,libtorrent::bdecode_node > *) 0 ;
  libtorrent::bdecode_node *arg2 = (libtorrent::bdecode_node *) 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 = (std::pair< libtorrent::string_view,libtorrent::bdecode_node > *) 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 = (std::pair< libtorrent::string_view,libtorrent::bdecode_node > *) 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1vectors_1pair_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::pair< std::vector< int8_t >,std::vector< int8_t > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< std::vector< int8_t >,std::vector< int8_t > > *)new std::pair< std::vector< int8_t >,std::vector< 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< int8_t >,std::vector< int8_t > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1vectors_1pair_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  std::vector< int8_t > arg1 ;
  std::vector< int8_t > arg2 ;
  std::vector< int8_t > *argp1 ;
  std::vector< int8_t > *argp2 ;
  std::pair< std::vector< int8_t >,std::vector< int8_t > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  argp1 = *(std::vector< int8_t > **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< int8_t >");
    return 0;
  }
  arg1 = *argp1; 
  argp2 = *(std::vector< int8_t > **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null std::vector< int8_t >");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (std::pair< std::vector< int8_t >,std::vector< int8_t > > *)new std::pair< std::vector< int8_t >,std::vector< 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< std::vector< int8_t >,std::vector< int8_t > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1byte_1vectors_1pair_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::pair< std::vector< int8_t >,std::vector< int8_t > > *arg1 = 0 ;
  std::pair< std::vector< int8_t >,std::vector< int8_t > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< std::vector< int8_t >,std::vector< int8_t > > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< std::vector< int8_t >,std::vector< int8_t > > const & reference is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< std::vector< int8_t >,std::vector< int8_t > > *)new std::pair< std::vector< int8_t >,std::vector< int8_t > >((std::pair< std::vector< int8_t >,std::vector< 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< int8_t >,std::vector< int8_t > > **)&jresult = result; 
  return jresult;
}


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


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


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


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


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1byte_1vectors_1pair(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::pair< std::vector< int8_t >,std::vector< int8_t > > *arg1 = (std::pair< std::vector< int8_t >,std::vector< int8_t > > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< std::vector< int8_t >,std::vector< 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::sha1_hash,libtorrent::udp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > *)new std::pair< libtorrent::sha1_hash,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::sha1_hash,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::sha1_hash arg1 ;
  libtorrent::udp::endpoint arg2 ;
  libtorrent::sha1_hash *argp1 ;
  libtorrent::udp::endpoint *argp2 ;
  std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > *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::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::sha1_hash,libtorrent::udp::endpoint > *)new std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint >(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< libtorrent::sha1_hash,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::sha1_hash,libtorrent::udp::endpoint > *arg1 = 0 ;
  std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > const & reference is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > *)new std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint >((std::pair< libtorrent::sha1_hash,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::sha1_hash,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::sha1_hash,libtorrent::udp::endpoint > *arg1 = (std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&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::sha1_hash,libtorrent::udp::endpoint > *arg1 = (std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > *) 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->first);
  *(libtorrent::sha1_hash **)&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::sha1_hash,libtorrent::udp::endpoint > *arg1 = (std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > *) 0 ;
  libtorrent::udp::endpoint *arg2 = (libtorrent::udp::endpoint *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::sha1_hash,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::sha1_hash,libtorrent::udp::endpoint > *arg1 = (std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > *) 0 ;
  libtorrent::udp::endpoint *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::sha1_hash,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::sha1_hash,libtorrent::udp::endpoint > *arg1 = (std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< libtorrent::sha1_hash,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_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::pair< libtorrent::address,libtorrent::sha1_hash > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::pair< libtorrent::address,libtorrent::sha1_hash > *)new std::pair< libtorrent::address,libtorrent::sha1_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;
    }
  }
  *(std::pair< libtorrent::address,libtorrent::sha1_hash > **)&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::sha1_hash arg2 ;
  libtorrent::address *argp1 ;
  libtorrent::sha1_hash *argp2 ;
  std::pair< libtorrent::address,libtorrent::sha1_hash > *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::sha1_hash **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::sha1_hash");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (std::pair< libtorrent::address,libtorrent::sha1_hash > *)new std::pair< libtorrent::address,libtorrent::sha1_hash >(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< libtorrent::address,libtorrent::sha1_hash > **)&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::sha1_hash > *arg1 = 0 ;
  std::pair< libtorrent::address,libtorrent::sha1_hash > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::address,libtorrent::sha1_hash > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::pair< libtorrent::address,libtorrent::sha1_hash > const & reference is null");
    return 0;
  } 
  {
    try {
      result = (std::pair< libtorrent::address,libtorrent::sha1_hash > *)new std::pair< libtorrent::address,libtorrent::sha1_hash >((std::pair< libtorrent::address,libtorrent::sha1_hash > 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::sha1_hash > **)&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::sha1_hash > *arg1 = (std::pair< libtorrent::address,libtorrent::sha1_hash > *) 0 ;
  libtorrent::address *arg2 = (libtorrent::address *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::address,libtorrent::sha1_hash > **)&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::sha1_hash > *arg1 = (std::pair< libtorrent::address,libtorrent::sha1_hash > *) 0 ;
  libtorrent::address *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::address,libtorrent::sha1_hash > **)&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::sha1_hash > *arg1 = (std::pair< libtorrent::address,libtorrent::sha1_hash > *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::pair< libtorrent::address,libtorrent::sha1_hash > **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&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::sha1_hash > *arg1 = (std::pair< libtorrent::address,libtorrent::sha1_hash > *) 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::pair< libtorrent::address,libtorrent::sha1_hash > **)&jarg1; 
  result = (libtorrent::sha1_hash *)& ((arg1)->second);
  *(libtorrent::sha1_hash **)&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::sha1_hash > *arg1 = (std::pair< libtorrent::address,libtorrent::sha1_hash > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::pair< libtorrent::address,libtorrent::sha1_hash > **)&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(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< int8_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< int8_t > *)new std::vector< 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< int8_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  std::vector< signed char >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int8_t > **)&jarg1; 
  {
    try {
      result = ((std::vector< int8_t > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  std::vector< signed char >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int8_t > **)&jarg1; 
  {
    try {
      result = ((std::vector< int8_t > const *)arg1)->capacity();
    } catch (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_byte_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  std::vector< signed char >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int8_t > **)&jarg1; 
  arg2 = (std::vector< signed char >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int8_t > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< 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< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jbyte jarg2) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 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< int8_t > **)&jarg1; 
  temp2 = (std::vector< signed char >::value_type)jarg2; 
  arg2 = &temp2; 
  {
    try {
      (arg1)->push_back((std::vector< signed char >::value_type 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_1resize(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  std::vector< signed char >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int8_t > **)&jarg1; 
  arg2 = (std::vector< signed char >::size_type)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 jbyte JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_byte_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jbyte jresult = 0 ;
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int arg2 ;
  int8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int8_t > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (int8_t)std_vector_Sl_int8_t_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_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jbyte jarg3) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  int 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< int8_t > **)&jarg1; 
  arg2 = (int)jarg2; 
  temp3 = (std::vector< signed char >::value_type)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_int8_t_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_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< int8_t > *arg1 = (std::vector< int8_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< 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_1vector(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_string_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::string > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::string > const *)arg1)->capacity();
    } catch (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_string_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  std::vector< std::string >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  arg2 = (std::vector< std::string >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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 = (std::vector< std::string > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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 = (const char *)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 {
      (arg1)->push_back((std::vector< std::string >::value_type 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_string_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jstring jresult = 0 ;
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::vector< std::string >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::string >::value_type *) &std_vector_Sl_std_string_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 = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ;
  int arg2 ;
  std::vector< std::string >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::string > **)&jarg1; 
  arg2 = (int)jarg2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = (const char *)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__set(arg1,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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1string_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::string > *arg1 = (std::vector< std::string > *) 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_1string_1int_1pair_1vector(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_string_1int_1pair_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,int > > *arg1 = (std::vector< std::pair< std::string,int > > *) 0 ;
  std::vector< std::pair< std::string,int > >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::pair< std::string,int > > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,int > > *arg1 = (std::vector< std::pair< std::string,int > > *) 0 ;
  std::vector< std::pair< std::string,int > >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::pair< std::string,int > > const *)arg1)->capacity();
    } catch (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_string_1int_1pair_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::pair< std::string,int > > *arg1 = (std::vector< std::pair< std::string,int > > *) 0 ;
  std::vector< std::pair< std::string,int > >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,int > > **)&jarg1; 
  arg2 = (std::vector< std::pair< std::string,int > >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::pair< std::string,int > > *arg1 = (std::vector< std::pair< std::string,int > > *) 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 = (std::vector< std::pair< std::string,int > > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::pair< std::string,int > > *arg1 = (std::vector< std::pair< std::string,int > > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< std::pair< std::string,int > >::value_type 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_string_1int_1pair_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,int > > *arg1 = (std::vector< std::pair< std::string,int > > *) 0 ;
  int 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 = (int)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__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;
    }
  }
  *(std::vector< std::pair< std::string,int > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1int_1pair_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::pair< std::string,int > > *arg1 = (std::vector< std::pair< std::string,int > > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_int_Sg__Sg__set(arg1,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 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 = (std::vector< std::pair< std::string,int > > *) 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(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_string_1string_1pair_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg1 = (std::vector< std::pair< std::string,std::string > > *) 0 ;
  std::vector< std::pair< std::string,std::string > >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::pair< std::string,std::string > > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg1 = (std::vector< std::pair< std::string,std::string > > *) 0 ;
  std::vector< std::pair< std::string,std::string > >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::pair< std::string,std::string > > const *)arg1)->capacity();
    } catch (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_string_1string_1pair_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::pair< std::string,std::string > > *arg1 = (std::vector< std::pair< std::string,std::string > > *) 0 ;
  std::vector< std::pair< std::string,std::string > >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< std::string,std::string > > **)&jarg1; 
  arg2 = (std::vector< std::pair< std::string,std::string > >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg1 = (std::vector< std::pair< std::string,std::string > > *) 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 = (std::vector< std::pair< std::string,std::string > > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::pair< std::string,std::string > > *arg1 = (std::vector< std::pair< std::string,std::string > > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< std::pair< std::string,std::string > >::value_type 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_string_1string_1pair_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< std::string,std::string > > *arg1 = (std::vector< std::pair< std::string,std::string > > *) 0 ;
  int 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 = (int)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__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;
    }
  }
  *(std::vector< std::pair< std::string,std::string > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1string_1pair_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::pair< std::string,std::string > > *arg1 = (std::vector< std::pair< std::string,std::string > > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_std_string_Sc_std_string_Sg__Sg__set(arg1,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 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 = (std::vector< std::pair< std::string,std::string > > *) 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_1piece_1index_1int_1pair_1vector(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::pair< piece_index_t,int > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::pair< piece_index_t,int > > *)new std::vector< 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::vector< std::pair< piece_index_t,int > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< piece_index_t,int > > *arg1 = (std::vector< std::pair< piece_index_t,int > > *) 0 ;
  std::vector< std::pair< piece_index_t,int > >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< piece_index_t,int > > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::pair< piece_index_t,int > > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< piece_index_t,int > > *arg1 = (std::vector< std::pair< piece_index_t,int > > *) 0 ;
  std::vector< std::pair< piece_index_t,int > >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< piece_index_t,int > > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::pair< piece_index_t,int > > const *)arg1)->capacity();
    } catch (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_piece_1index_1int_1pair_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::pair< piece_index_t,int > > *arg1 = (std::vector< std::pair< piece_index_t,int > > *) 0 ;
  std::vector< std::pair< piece_index_t,int > >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< piece_index_t,int > > **)&jarg1; 
  arg2 = (std::vector< std::pair< piece_index_t,int > >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::pair< piece_index_t,int > > *arg1 = (std::vector< std::pair< piece_index_t,int > > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< piece_index_t,int > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::pair< 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< piece_index_t,int > > *arg1 = (std::vector< std::pair< piece_index_t,int > > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::pair< piece_index_t,int > > *arg1 = (std::vector< std::pair< piece_index_t,int > > *) 0 ;
  std::vector< std::pair< piece_index_t,int > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< std::pair< piece_index_t,int > > **)&jarg1; 
  arg2 = *(std::vector< std::pair< piece_index_t,int > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< piece_index_t,int > >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< std::pair< piece_index_t,int > >::value_type 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_piece_1index_1int_1pair_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< piece_index_t,int > > *arg1 = (std::vector< std::pair< piece_index_t,int > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< piece_index_t,int > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< piece_index_t,int > > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< piece_index_t,int > >::value_type *) &std_vector_Sl_std_pair_Sl_piece_index_t_Sc_int_Sg__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;
    }
  }
  *(std::vector< std::pair< piece_index_t,int > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1int_1pair_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::pair< piece_index_t,int > > *arg1 = (std::vector< std::pair< piece_index_t,int > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< piece_index_t,int > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< piece_index_t,int > > **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< std::pair< piece_index_t,int > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< piece_index_t,int > >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_piece_index_t_Sc_int_Sg__Sg__set(arg1,arg2,(std::pair< 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 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< piece_index_t,int > > *arg1 = (std::vector< std::pair< piece_index_t,int > > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< 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_1int_1vector(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_int_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  {
    try {
      result = ((std::vector< int > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  {
    try {
      result = ((std::vector< int > const *)arg1)->capacity();
    } catch (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_int_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  std::vector< int >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  arg2 = (std::vector< int >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< int > *arg1 = (std::vector< int > *) 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 = (std::vector< int > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  std::vector< int > *arg1 = (std::vector< int > *) 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 {
      (arg1)->push_back((std::vector< int >::value_type 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_int_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jint jresult = 0 ;
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int arg2 ;
  std::vector< int >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< int > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< int >::value_type *) &std_vector_Sl_int_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 = (jint)*result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  std::vector< int > *arg1 = (std::vector< int > *) 0 ;
  int 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 = (int)jarg2; 
  temp3 = (std::vector< int >::value_type)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_int_Sg__set(arg1,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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1int_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< int > *arg1 = (std::vector< int > *) 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(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_int64_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< long long > *arg1 = (std::vector< long long > *) 0 ;
  std::vector< long long >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  {
    try {
      result = ((std::vector< long long > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< long long > *arg1 = (std::vector< long long > *) 0 ;
  std::vector< long long >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  {
    try {
      result = ((std::vector< long long > const *)arg1)->capacity();
    } catch (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_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< long long > *arg1 = (std::vector< long long > *) 0 ;
  std::vector< long long >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  arg2 = (std::vector< long long >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< long long > *arg1 = (std::vector< long long > *) 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 = (std::vector< long long > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< long long > *arg1 = (std::vector< long long > *) 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 {
      (arg1)->push_back((std::vector< long long >::value_type 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_int64_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< long long > *arg1 = (std::vector< long long > *) 0 ;
  int arg2 ;
  std::vector< long long >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< long long > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< long long >::value_type *) &std_vector_Sl_long_SS_long_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 = (jlong)*result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_int64_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3) {
  std::vector< long long > *arg1 = (std::vector< long long > *) 0 ;
  int 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 = (int)jarg2; 
  temp3 = (std::vector< long long >::value_type)jarg3; 
  arg3 = &temp3; 
  {
    try {
      try {
        std_vector_Sl_long_SS_long_Sg__set(arg1,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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1int64_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< long long > *arg1 = (std::vector< long long > *) 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_1sha1_1hash_1vector(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< libtorrent::sha1_hash > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< libtorrent::sha1_hash > *)new std::vector< libtorrent::sha1_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;
    }
  }
  *(std::vector< libtorrent::sha1_hash > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::sha1_hash > *arg1 = (std::vector< libtorrent::sha1_hash > *) 0 ;
  std::vector< libtorrent::sha1_hash >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::sha1_hash > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::sha1_hash > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::sha1_hash > *arg1 = (std::vector< libtorrent::sha1_hash > *) 0 ;
  std::vector< libtorrent::sha1_hash >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::sha1_hash > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::sha1_hash > const *)arg1)->capacity();
    } catch (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_sha1_1hash_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::sha1_hash > *arg1 = (std::vector< libtorrent::sha1_hash > *) 0 ;
  std::vector< libtorrent::sha1_hash >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::sha1_hash > **)&jarg1; 
  arg2 = (std::vector< libtorrent::sha1_hash >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::sha1_hash > *arg1 = (std::vector< libtorrent::sha1_hash > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::sha1_hash > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< libtorrent::sha1_hash > 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::sha1_hash > *arg1 = (std::vector< libtorrent::sha1_hash > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::sha1_hash > **)&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_sha1_1hash_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::sha1_hash > *arg1 = (std::vector< libtorrent::sha1_hash > *) 0 ;
  std::vector< libtorrent::sha1_hash >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< libtorrent::sha1_hash > **)&jarg1; 
  arg2 = *(std::vector< libtorrent::sha1_hash >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::sha1_hash >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::sha1_hash >::value_type 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_sha1_1hash_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::sha1_hash > *arg1 = (std::vector< libtorrent::sha1_hash > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::sha1_hash >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::sha1_hash > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::sha1_hash >::value_type *) &std_vector_Sl_libtorrent_sha1_hash_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;
    }
  }
  *(std::vector< libtorrent::sha1_hash >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::sha1_hash > *arg1 = (std::vector< libtorrent::sha1_hash > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::sha1_hash >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::sha1_hash > **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< libtorrent::sha1_hash >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::sha1_hash >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_sha1_hash_Sg__set(arg1,arg2,(libtorrent::sha1_hash 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_1sha1_1hash_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::sha1_hash > *arg1 = (std::vector< libtorrent::sha1_hash > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< libtorrent::sha1_hash > **)&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(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_torrent_1status_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_status > *arg1 = (std::vector< libtorrent::torrent_status > *) 0 ;
  std::vector< libtorrent::torrent_status >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::torrent_status > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_status > *arg1 = (std::vector< libtorrent::torrent_status > *) 0 ;
  std::vector< libtorrent::torrent_status >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::torrent_status > const *)arg1)->capacity();
    } catch (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_torrent_1status_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::torrent_status > *arg1 = (std::vector< libtorrent::torrent_status > *) 0 ;
  std::vector< libtorrent::torrent_status >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  arg2 = (std::vector< libtorrent::torrent_status >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::torrent_status > *arg1 = (std::vector< libtorrent::torrent_status > *) 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 = (std::vector< libtorrent::torrent_status > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::torrent_status > *arg1 = (std::vector< libtorrent::torrent_status > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::torrent_status >::value_type 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_1status_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_status > *arg1 = (std::vector< libtorrent::torrent_status > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::torrent_status >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_status > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::torrent_status >::value_type *) &std_vector_Sl_libtorrent_torrent_status_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;
    }
  }
  *(std::vector< libtorrent::torrent_status >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::torrent_status > *arg1 = (std::vector< libtorrent::torrent_status > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_torrent_status_Sg__set(arg1,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 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 = (std::vector< libtorrent::torrent_status > *) 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_1torrent_1handle_1vector(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_torrent_1handle_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *arg1 = (std::vector< libtorrent::torrent_handle > *) 0 ;
  std::vector< libtorrent::torrent_handle >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::torrent_handle > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *arg1 = (std::vector< libtorrent::torrent_handle > *) 0 ;
  std::vector< libtorrent::torrent_handle >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::torrent_handle > const *)arg1)->capacity();
    } catch (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_torrent_1handle_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::torrent_handle > *arg1 = (std::vector< libtorrent::torrent_handle > *) 0 ;
  std::vector< libtorrent::torrent_handle >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  arg2 = (std::vector< libtorrent::torrent_handle >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *arg1 = (std::vector< libtorrent::torrent_handle > *) 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 = (std::vector< libtorrent::torrent_handle > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::torrent_handle > *arg1 = (std::vector< libtorrent::torrent_handle > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::torrent_handle >::value_type 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_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::torrent_handle > *arg1 = (std::vector< libtorrent::torrent_handle > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::torrent_handle >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::torrent_handle > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::torrent_handle >::value_type *) &std_vector_Sl_libtorrent_torrent_handle_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;
    }
  }
  *(std::vector< libtorrent::torrent_handle >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::torrent_handle > *arg1 = (std::vector< libtorrent::torrent_handle > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_torrent_handle_Sg__set(arg1,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 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 = (std::vector< libtorrent::torrent_handle > *) 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_1file_1slice_1vector(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_file_1slice_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_slice > *arg1 = (std::vector< libtorrent::file_slice > *) 0 ;
  std::vector< libtorrent::file_slice >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::file_slice > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_slice > *arg1 = (std::vector< libtorrent::file_slice > *) 0 ;
  std::vector< libtorrent::file_slice >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::file_slice > const *)arg1)->capacity();
    } catch (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_1slice_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::file_slice > *arg1 = (std::vector< libtorrent::file_slice > *) 0 ;
  std::vector< libtorrent::file_slice >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  arg2 = (std::vector< libtorrent::file_slice >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::file_slice > *arg1 = (std::vector< libtorrent::file_slice > *) 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 = (std::vector< libtorrent::file_slice > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::file_slice > *arg1 = (std::vector< libtorrent::file_slice > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::file_slice >::value_type 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_file_1slice_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::file_slice > *arg1 = (std::vector< libtorrent::file_slice > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::file_slice >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::file_slice > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::file_slice >::value_type *) &std_vector_Sl_libtorrent_file_slice_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;
    }
  }
  *(std::vector< libtorrent::file_slice >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1slice_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::file_slice > *arg1 = (std::vector< libtorrent::file_slice > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_file_slice_Sg__set(arg1,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 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 = (std::vector< libtorrent::file_slice > *) 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_1dht_1routing_1bucket_1vector(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_dht_1routing_1bucket_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg1 = (std::vector< libtorrent::dht_routing_bucket > *) 0 ;
  std::vector< libtorrent::dht_routing_bucket >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::dht_routing_bucket > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg1 = (std::vector< libtorrent::dht_routing_bucket > *) 0 ;
  std::vector< libtorrent::dht_routing_bucket >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::dht_routing_bucket > const *)arg1)->capacity();
    } catch (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_dht_1routing_1bucket_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::dht_routing_bucket > *arg1 = (std::vector< libtorrent::dht_routing_bucket > *) 0 ;
  std::vector< libtorrent::dht_routing_bucket >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_routing_bucket > **)&jarg1; 
  arg2 = (std::vector< libtorrent::dht_routing_bucket >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg1 = (std::vector< libtorrent::dht_routing_bucket > *) 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 = (std::vector< libtorrent::dht_routing_bucket > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::dht_routing_bucket > *arg1 = (std::vector< libtorrent::dht_routing_bucket > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::dht_routing_bucket >::value_type 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_dht_1routing_1bucket_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg1 = (std::vector< libtorrent::dht_routing_bucket > *) 0 ;
  int 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 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::dht_routing_bucket >::value_type *) &std_vector_Sl_libtorrent_dht_routing_bucket_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;
    }
  }
  *(std::vector< libtorrent::dht_routing_bucket >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1routing_1bucket_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::dht_routing_bucket > *arg1 = (std::vector< libtorrent::dht_routing_bucket > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_dht_routing_bucket_Sg__set(arg1,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 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 = (std::vector< libtorrent::dht_routing_bucket > *) 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_1dht_1lookup_1vector(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_dht_1lookup_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *arg1 = (std::vector< libtorrent::dht_lookup > *) 0 ;
  std::vector< libtorrent::dht_lookup >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::dht_lookup > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *arg1 = (std::vector< libtorrent::dht_lookup > *) 0 ;
  std::vector< libtorrent::dht_lookup >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::dht_lookup > const *)arg1)->capacity();
    } catch (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_dht_1lookup_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::dht_lookup > *arg1 = (std::vector< libtorrent::dht_lookup > *) 0 ;
  std::vector< libtorrent::dht_lookup >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  arg2 = (std::vector< libtorrent::dht_lookup >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *arg1 = (std::vector< libtorrent::dht_lookup > *) 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 = (std::vector< libtorrent::dht_lookup > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::dht_lookup > *arg1 = (std::vector< libtorrent::dht_lookup > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::dht_lookup >::value_type 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_dht_1lookup_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::dht_lookup > *arg1 = (std::vector< libtorrent::dht_lookup > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::dht_lookup >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::dht_lookup > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::dht_lookup >::value_type *) &std_vector_Sl_libtorrent_dht_lookup_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;
    }
  }
  *(std::vector< libtorrent::dht_lookup >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1lookup_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::dht_lookup > *arg1 = (std::vector< libtorrent::dht_lookup > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_dht_lookup_Sg__set(arg1,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 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 = (std::vector< libtorrent::dht_lookup > *) 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_1block_1info_1vector(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_block_1info_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::block_info > *arg1 = (std::vector< libtorrent::block_info > *) 0 ;
  std::vector< libtorrent::block_info >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::block_info > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::block_info > *arg1 = (std::vector< libtorrent::block_info > *) 0 ;
  std::vector< libtorrent::block_info >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::block_info > const *)arg1)->capacity();
    } catch (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_block_1info_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::block_info > *arg1 = (std::vector< libtorrent::block_info > *) 0 ;
  std::vector< libtorrent::block_info >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  arg2 = (std::vector< libtorrent::block_info >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::block_info > *arg1 = (std::vector< libtorrent::block_info > *) 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 = (std::vector< libtorrent::block_info > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::block_info > *arg1 = (std::vector< libtorrent::block_info > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::block_info >::value_type 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_block_1info_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::block_info > *arg1 = (std::vector< libtorrent::block_info > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::block_info >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::block_info > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::block_info >::value_type *) &std_vector_Sl_libtorrent_block_info_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;
    }
  }
  *(std::vector< libtorrent::block_info >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_block_1info_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::block_info > *arg1 = (std::vector< libtorrent::block_info > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_block_info_Sg__set(arg1,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 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 = (std::vector< libtorrent::block_info > *) 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_1partial_1piece_1info_1vector(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_partial_1piece_1info_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg1 = (std::vector< libtorrent::partial_piece_info > *) 0 ;
  std::vector< libtorrent::partial_piece_info >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::partial_piece_info > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg1 = (std::vector< libtorrent::partial_piece_info > *) 0 ;
  std::vector< libtorrent::partial_piece_info >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::partial_piece_info > const *)arg1)->capacity();
    } catch (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_partial_1piece_1info_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::partial_piece_info > *arg1 = (std::vector< libtorrent::partial_piece_info > *) 0 ;
  std::vector< libtorrent::partial_piece_info >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::partial_piece_info > **)&jarg1; 
  arg2 = (std::vector< libtorrent::partial_piece_info >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg1 = (std::vector< libtorrent::partial_piece_info > *) 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 = (std::vector< libtorrent::partial_piece_info > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::partial_piece_info > *arg1 = (std::vector< libtorrent::partial_piece_info > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::partial_piece_info >::value_type 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_partial_1piece_1info_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::partial_piece_info > *arg1 = (std::vector< libtorrent::partial_piece_info > *) 0 ;
  int 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 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::partial_piece_info >::value_type *) &std_vector_Sl_libtorrent_partial_piece_info_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;
    }
  }
  *(std::vector< libtorrent::partial_piece_info >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_partial_1piece_1info_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::partial_piece_info > *arg1 = (std::vector< libtorrent::partial_piece_info > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_partial_piece_info_Sg__set(arg1,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 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 = (std::vector< libtorrent::partial_piece_info > *) 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(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_peer_1info_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::peer_info > *arg1 = (std::vector< libtorrent::peer_info > *) 0 ;
  std::vector< libtorrent::peer_info >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::peer_info > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::peer_info > *arg1 = (std::vector< libtorrent::peer_info > *) 0 ;
  std::vector< libtorrent::peer_info >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::peer_info > const *)arg1)->capacity();
    } catch (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_peer_1info_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::peer_info > *arg1 = (std::vector< libtorrent::peer_info > *) 0 ;
  std::vector< libtorrent::peer_info >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  arg2 = (std::vector< libtorrent::peer_info >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::peer_info > *arg1 = (std::vector< libtorrent::peer_info > *) 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 = (std::vector< libtorrent::peer_info > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::peer_info > *arg1 = (std::vector< libtorrent::peer_info > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::peer_info >::value_type 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_peer_1info_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::peer_info > *arg1 = (std::vector< libtorrent::peer_info > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::peer_info >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::peer_info > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::peer_info >::value_type *) &std_vector_Sl_libtorrent_peer_info_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;
    }
  }
  *(std::vector< libtorrent::peer_info >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::peer_info > *arg1 = (std::vector< libtorrent::peer_info > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_peer_info_Sg__set(arg1,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 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 = (std::vector< libtorrent::peer_info > *) 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_1stats_1metric_1vector(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_stats_1metric_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::stats_metric > *arg1 = (std::vector< libtorrent::stats_metric > *) 0 ;
  std::vector< libtorrent::stats_metric >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::stats_metric > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::stats_metric > *arg1 = (std::vector< libtorrent::stats_metric > *) 0 ;
  std::vector< libtorrent::stats_metric >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::stats_metric > const *)arg1)->capacity();
    } catch (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_stats_1metric_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::stats_metric > *arg1 = (std::vector< libtorrent::stats_metric > *) 0 ;
  std::vector< libtorrent::stats_metric >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  arg2 = (std::vector< libtorrent::stats_metric >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::stats_metric > *arg1 = (std::vector< libtorrent::stats_metric > *) 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 = (std::vector< libtorrent::stats_metric > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::stats_metric > *arg1 = (std::vector< libtorrent::stats_metric > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::stats_metric >::value_type 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_stats_1metric_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::stats_metric > *arg1 = (std::vector< libtorrent::stats_metric > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::stats_metric >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::stats_metric > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::stats_metric >::value_type *) &std_vector_Sl_libtorrent_stats_metric_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;
    }
  }
  *(std::vector< libtorrent::stats_metric >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1metric_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::stats_metric > *arg1 = (std::vector< libtorrent::stats_metric > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_stats_metric_Sg__set(arg1,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 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 = (std::vector< libtorrent::stats_metric > *) 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_1entry_1vector(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_entry_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::entry > *arg1 = (std::vector< libtorrent::entry > *) 0 ;
  std::vector< libtorrent::entry >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  {
    try {
      result = ((std::vector< 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::entry > *arg1 = (std::vector< libtorrent::entry > *) 0 ;
  std::vector< libtorrent::entry >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::entry > const *)arg1)->capacity();
    } catch (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_entry_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::entry > *arg1 = (std::vector< libtorrent::entry > *) 0 ;
  std::vector< libtorrent::entry >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  arg2 = (std::vector< libtorrent::entry >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::entry > *arg1 = (std::vector< libtorrent::entry > *) 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 = (std::vector< libtorrent::entry > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::entry > *arg1 = (std::vector< libtorrent::entry > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::entry >::value_type 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_entry_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::entry > *arg1 = (std::vector< libtorrent::entry > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::entry >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::entry >::value_type *) &std_vector_Sl_libtorrent_entry_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;
    }
  }
  *(std::vector< libtorrent::entry >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::entry > *arg1 = (std::vector< libtorrent::entry > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::entry >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< libtorrent::entry > **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< libtorrent::entry >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::entry >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_entry_Sg__set(arg1,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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1entry_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::entry > *arg1 = (std::vector< libtorrent::entry > *) 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_1web_1seed_1entry_1vector(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_web_1seed_1entry_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *arg1 = (std::vector< libtorrent::web_seed_entry > *) 0 ;
  std::vector< libtorrent::web_seed_entry >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::web_seed_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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *arg1 = (std::vector< libtorrent::web_seed_entry > *) 0 ;
  std::vector< libtorrent::web_seed_entry >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::web_seed_entry > const *)arg1)->capacity();
    } catch (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_web_1seed_1entry_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::web_seed_entry > *arg1 = (std::vector< libtorrent::web_seed_entry > *) 0 ;
  std::vector< libtorrent::web_seed_entry >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::web_seed_entry > **)&jarg1; 
  arg2 = (std::vector< libtorrent::web_seed_entry >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *arg1 = (std::vector< libtorrent::web_seed_entry > *) 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 = (std::vector< libtorrent::web_seed_entry > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::web_seed_entry > *arg1 = (std::vector< libtorrent::web_seed_entry > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::web_seed_entry >::value_type 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_web_1seed_1entry_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::web_seed_entry > *arg1 = (std::vector< libtorrent::web_seed_entry > *) 0 ;
  int 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 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::web_seed_entry >::value_type *) &std_vector_Sl_libtorrent_web_seed_entry_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;
    }
  }
  *(std::vector< libtorrent::web_seed_entry >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_web_1seed_1entry_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::web_seed_entry > *arg1 = (std::vector< libtorrent::web_seed_entry > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_web_seed_entry_Sg__set(arg1,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 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 = (std::vector< libtorrent::web_seed_entry > *) 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_1announce_1endpoint_1vector(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_announce_1endpoint_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg1 = (std::vector< libtorrent::announce_endpoint > *) 0 ;
  std::vector< libtorrent::announce_endpoint >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::announce_endpoint > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg1 = (std::vector< libtorrent::announce_endpoint > *) 0 ;
  std::vector< libtorrent::announce_endpoint >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::announce_endpoint > const *)arg1)->capacity();
    } catch (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_announce_1endpoint_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::announce_endpoint > *arg1 = (std::vector< libtorrent::announce_endpoint > *) 0 ;
  std::vector< libtorrent::announce_endpoint >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  arg2 = (std::vector< libtorrent::announce_endpoint >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg1 = (std::vector< libtorrent::announce_endpoint > *) 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 = (std::vector< libtorrent::announce_endpoint > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::announce_endpoint > *arg1 = (std::vector< libtorrent::announce_endpoint > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::announce_endpoint >::value_type 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_1endpoint_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_endpoint > *arg1 = (std::vector< libtorrent::announce_endpoint > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::announce_endpoint >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_endpoint > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::announce_endpoint >::value_type *) &std_vector_Sl_libtorrent_announce_endpoint_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;
    }
  }
  *(std::vector< libtorrent::announce_endpoint >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::announce_endpoint > *arg1 = (std::vector< libtorrent::announce_endpoint > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_announce_endpoint_Sg__set(arg1,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 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 = (std::vector< libtorrent::announce_endpoint > *) 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(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_announce_1entry_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_entry > *arg1 = (std::vector< libtorrent::announce_entry > *) 0 ;
  std::vector< libtorrent::announce_entry >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::announce_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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_entry > *arg1 = (std::vector< libtorrent::announce_entry > *) 0 ;
  std::vector< libtorrent::announce_entry >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::announce_entry > const *)arg1)->capacity();
    } catch (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_announce_1entry_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::announce_entry > *arg1 = (std::vector< libtorrent::announce_entry > *) 0 ;
  std::vector< libtorrent::announce_entry >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  arg2 = (std::vector< libtorrent::announce_entry >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::announce_entry > *arg1 = (std::vector< libtorrent::announce_entry > *) 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 = (std::vector< libtorrent::announce_entry > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::announce_entry > *arg1 = (std::vector< libtorrent::announce_entry > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::announce_entry >::value_type 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_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::announce_entry > *arg1 = (std::vector< libtorrent::announce_entry > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::announce_entry >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::announce_entry > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::announce_entry >::value_type *) &std_vector_Sl_libtorrent_announce_entry_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;
    }
  }
  *(std::vector< libtorrent::announce_entry >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1entry_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::announce_entry > *arg1 = (std::vector< libtorrent::announce_entry > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_announce_entry_Sg__set(arg1,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 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 = (std::vector< libtorrent::announce_entry > *) 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_1tcp_1endpoint_1vector(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_tcp_1endpoint_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg1 = (std::vector< libtorrent::tcp::endpoint > *) 0 ;
  std::vector< libtorrent::tcp::endpoint >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::tcp::endpoint > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg1 = (std::vector< libtorrent::tcp::endpoint > *) 0 ;
  std::vector< libtorrent::tcp::endpoint >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::tcp::endpoint > const *)arg1)->capacity();
    } catch (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_tcp_1endpoint_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::tcp::endpoint > *arg1 = (std::vector< libtorrent::tcp::endpoint > *) 0 ;
  std::vector< libtorrent::tcp::endpoint >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  arg2 = (std::vector< libtorrent::tcp::endpoint >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg1 = (std::vector< libtorrent::tcp::endpoint > *) 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 = (std::vector< libtorrent::tcp::endpoint > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::tcp::endpoint > *arg1 = (std::vector< libtorrent::tcp::endpoint > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::tcp::endpoint >::value_type 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_tcp_1endpoint_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::tcp::endpoint > *arg1 = (std::vector< libtorrent::tcp::endpoint > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::tcp::endpoint >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::tcp::endpoint > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::tcp::endpoint >::value_type *) &std_vector_Sl_libtorrent_tcp_endpoint_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;
    }
  }
  *(std::vector< libtorrent::tcp::endpoint >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_tcp_1endpoint_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::tcp::endpoint > *arg1 = (std::vector< libtorrent::tcp::endpoint > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_tcp_endpoint_Sg__set(arg1,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 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 = (std::vector< libtorrent::tcp::endpoint > *) 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(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_udp_1endpoint_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg1 = (std::vector< libtorrent::udp::endpoint > *) 0 ;
  std::vector< libtorrent::udp::endpoint >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::udp::endpoint > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg1 = (std::vector< libtorrent::udp::endpoint > *) 0 ;
  std::vector< libtorrent::udp::endpoint >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::udp::endpoint > const *)arg1)->capacity();
    } catch (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_udp_1endpoint_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::udp::endpoint > *arg1 = (std::vector< libtorrent::udp::endpoint > *) 0 ;
  std::vector< libtorrent::udp::endpoint >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = (std::vector< libtorrent::udp::endpoint >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg1 = (std::vector< libtorrent::udp::endpoint > *) 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 = (std::vector< libtorrent::udp::endpoint > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::udp::endpoint > *arg1 = (std::vector< libtorrent::udp::endpoint > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< libtorrent::udp::endpoint >::value_type 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_udp_1endpoint_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::udp::endpoint > *arg1 = (std::vector< libtorrent::udp::endpoint > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::udp::endpoint >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::udp::endpoint > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::udp::endpoint >::value_type *) &std_vector_Sl_libtorrent_udp_endpoint_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;
    }
  }
  *(std::vector< libtorrent::udp::endpoint >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_udp_1endpoint_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::udp::endpoint > *arg1 = (std::vector< libtorrent::udp::endpoint > *) 0 ;
  int 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 = (int)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 & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_libtorrent_udp_endpoint_Sg__set(arg1,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 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 = (std::vector< libtorrent::udp::endpoint > *) 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_1piece_1index_1vector(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< piece_index_t > *)new std::vector< 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< piece_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< piece_index_t > *arg1 = (std::vector< piece_index_t > *) 0 ;
  std::vector< piece_index_t >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< piece_index_t > **)&jarg1; 
  {
    try {
      result = ((std::vector< piece_index_t > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< piece_index_t > *arg1 = (std::vector< piece_index_t > *) 0 ;
  std::vector< piece_index_t >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< piece_index_t > **)&jarg1; 
  {
    try {
      result = ((std::vector< piece_index_t > const *)arg1)->capacity();
    } catch (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_piece_1index_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< piece_index_t > *arg1 = (std::vector< piece_index_t > *) 0 ;
  std::vector< piece_index_t >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< piece_index_t > **)&jarg1; 
  arg2 = (std::vector< piece_index_t >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< piece_index_t > *arg1 = (std::vector< piece_index_t > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< piece_index_t > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< 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< piece_index_t > *arg1 = (std::vector< piece_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  std::vector< piece_index_t > *arg1 = (std::vector< piece_index_t > *) 0 ;
  std::vector< piece_index_t >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< piece_index_t > **)&jarg1; 
  arg2 = *(std::vector< piece_index_t >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< piece_index_t >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< piece_index_t >::value_type 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 int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  int jresult = 0 ;
  std::vector< piece_index_t > *arg1 = (std::vector< piece_index_t > *) 0 ;
  int arg2 ;
  std::vector< piece_index_t >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< piece_index_t > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< piece_index_t >::value_type *) &std_vector_Sl_piece_index_t_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;
    }
  }
  *(std::vector< piece_index_t >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, int jarg3) {
  std::vector< piece_index_t > *arg1 = (std::vector< piece_index_t > *) 0 ;
  int arg2 ;
  std::vector< piece_index_t >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< piece_index_t > **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< piece_index_t >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< piece_index_t >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_piece_index_t_Sg__set(arg1,arg2,(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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1piece_1index_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< piece_index_t > *arg1 = (std::vector< piece_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< 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_1file_1index_1vector(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< file_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< file_index_t > *)new std::vector< 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< file_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< file_index_t > *arg1 = (std::vector< file_index_t > *) 0 ;
  std::vector< file_index_t >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< file_index_t > **)&jarg1; 
  {
    try {
      result = ((std::vector< file_index_t > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< file_index_t > *arg1 = (std::vector< file_index_t > *) 0 ;
  std::vector< file_index_t >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< file_index_t > **)&jarg1; 
  {
    try {
      result = ((std::vector< file_index_t > const *)arg1)->capacity();
    } catch (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_1index_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< file_index_t > *arg1 = (std::vector< file_index_t > *) 0 ;
  std::vector< file_index_t >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< file_index_t > **)&jarg1; 
  arg2 = (std::vector< file_index_t >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< file_index_t > *arg1 = (std::vector< file_index_t > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< file_index_t > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< 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< file_index_t > *arg1 = (std::vector< file_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  std::vector< file_index_t > *arg1 = (std::vector< file_index_t > *) 0 ;
  std::vector< file_index_t >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< file_index_t > **)&jarg1; 
  arg2 = *(std::vector< file_index_t >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< file_index_t >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< file_index_t >::value_type 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 int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  int jresult = 0 ;
  std::vector< file_index_t > *arg1 = (std::vector< file_index_t > *) 0 ;
  int arg2 ;
  std::vector< file_index_t >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< file_index_t > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< file_index_t >::value_type *) &std_vector_Sl_file_index_t_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;
    }
  }
  *(std::vector< file_index_t >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, int jarg3) {
  std::vector< file_index_t > *arg1 = (std::vector< file_index_t > *) 0 ;
  int arg2 ;
  std::vector< file_index_t >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< file_index_t > **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< file_index_t >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< file_index_t >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_file_index_t_Sg__set(arg1,arg2,(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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1index_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< file_index_t > *arg1 = (std::vector< file_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< 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_1sha1_1hash_1udp_1endpoint_1pair_1vector(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *)new std::vector< std::pair< libtorrent::sha1_hash,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::sha1_hash,libtorrent::udp::endpoint > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *arg1 = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *) 0 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *arg1 = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *) 0 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > const *)arg1)->capacity();
    } catch (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_sha1_1hash_1udp_1endpoint_1pair_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *arg1 = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *) 0 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > **)&jarg1; 
  arg2 = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *arg1 = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::pair< libtorrent::sha1_hash,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::sha1_hash,libtorrent::udp::endpoint > > *arg1 = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::sha1_hash,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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *arg1 = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *) 0 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > **)&jarg1; 
  arg2 = *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::value_type 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_sha1_1hash_1udp_1endpoint_1pair_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *arg1 = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::value_type *) &std_vector_Sl_std_pair_Sl_libtorrent_sha1_hash_Sc_libtorrent_udp_endpoint_Sg__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;
    }
  }
  *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1udp_1endpoint_1pair_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *arg1 = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_libtorrent_sha1_hash_Sc_libtorrent_udp_endpoint_Sg__Sg__set(arg1,arg2,(std::pair< libtorrent::sha1_hash,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 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::sha1_hash,libtorrent::udp::endpoint > > *arg1 = (std::vector< std::pair< libtorrent::sha1_hash,libtorrent::udp::endpoint > > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::pair< libtorrent::sha1_hash,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(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *)new std::vector< std::pair< libtorrent::address,libtorrent::sha1_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;
    }
  }
  *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *arg1 = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *) 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *arg1 = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *) 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&jarg1; 
  {
    try {
      result = ((std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > const *)arg1)->capacity();
    } catch (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_address_1sha1_1hash_1pair_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *arg1 = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *) 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&jarg1; 
  arg2 = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *arg1 = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > 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::sha1_hash > > *arg1 = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&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_address_1sha1_1hash_1pair_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *arg1 = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *) 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&jarg1; 
  arg2 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::value_type 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_address_1sha1_1hash_1pair_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *arg1 = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::value_type *) &std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_sha1_hash_Sg__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;
    }
  }
  *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_address_1sha1_1hash_1pair_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *arg1 = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *) 0 ;
  int arg2 ;
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_std_pair_Sl_libtorrent_address_Sc_libtorrent_sha1_hash_Sg__Sg__set(arg1,arg2,(std::pair< libtorrent::address,libtorrent::sha1_hash > 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_1address_1sha1_1hash_1pair_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *arg1 = (std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< std::pair< libtorrent::address,libtorrent::sha1_hash > > **)&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< file_index_t,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::map< file_index_t,std::string > *)new std::map< 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< 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< file_index_t,std::string > *arg1 = 0 ;
  std::map< file_index_t,std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< file_index_t,std::string > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< file_index_t,std::string > const & reference is null");
    return 0;
  } 
  {
    try {
      result = (std::map< file_index_t,std::string > *)new std::map< file_index_t,std::string >((std::map< 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< file_index_t,std::string > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< file_index_t,std::string > *arg1 = (std::map< file_index_t,std::string > *) 0 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< file_index_t,std::string > **)&jarg1; 
  {
    try {
      result = (unsigned int)((std::map< file_index_t,std::string > 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_file_1index_1string_1map_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< file_index_t,std::string > *arg1 = (std::map< file_index_t,std::string > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< file_index_t,std::string > **)&jarg1; 
  {
    try {
      result = (bool)((std::map< 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< file_index_t,std::string > *arg1 = (std::map< file_index_t,std::string > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< 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 jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jstring jresult = 0 ;
  std::map< file_index_t,std::string > *arg1 = (std::map< file_index_t,std::string > *) 0 ;
  file_index_t *arg2 = 0 ;
  std::string *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< file_index_t,std::string > **)&jarg1; 
  arg2 = *(file_index_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "file_index_t const & reference is null");
    return 0;
  } 
  {
    try {
      try {
        result = (std::string *) &std_map_Sl_file_index_t_Sc_std_string_Sg__get(arg1,(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;
    }
  }
  jresult = jenv->NewStringUTF(result->c_str()); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jstring jarg3) {
  std::map< file_index_t,std::string > *arg1 = (std::map< file_index_t,std::string > *) 0 ;
  file_index_t *arg2 = 0 ;
  std::string *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< file_index_t,std::string > **)&jarg1; 
  arg2 = *(file_index_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "file_index_t const & reference is null");
    return ;
  } 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = (const char *)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_file_index_t_Sc_std_string_Sg__set(arg1,(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_1erase(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  std::map< file_index_t,std::string > *arg1 = (std::map< file_index_t,std::string > *) 0 ;
  file_index_t *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< file_index_t,std::string > **)&jarg1; 
  arg2 = *(file_index_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "file_index_t const & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_map_Sl_file_index_t_Sc_std_string_Sg__erase(arg1,(file_index_t const &)*arg2);
      } 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_file_1index_1string_1map_1has_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jboolean jresult = 0 ;
  std::map< file_index_t,std::string > *arg1 = (std::map< file_index_t,std::string > *) 0 ;
  file_index_t *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< file_index_t,std::string > **)&jarg1; 
  arg2 = *(file_index_t **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "file_index_t const & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)std_map_Sl_file_index_t_Sc_std_string_Sg__has_key(arg1,(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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1index_1string_1map_1keys(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< file_index_t,std::string > *arg1 = (std::map< file_index_t,std::string > *) 0 ;
  std::vector< file_index_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< file_index_t,std::string > **)&jarg1; 
  {
    try {
      result = std_map_Sl_file_index_t_Sc_std_string_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< file_index_t > **)&jresult = new std::vector< file_index_t >((const std::vector< file_index_t > &)result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1file_1index_1string_1map(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::map< file_index_t,std::string > *arg1 = (std::map< file_index_t,std::string > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::map< 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_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 & reference 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_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,long > *arg1 = (std::map< std::string,long > *) 0 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  {
    try {
      result = (unsigned int)((std::map< std::string,long > 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_string_1long_1map_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,long > *arg1 = (std::map< std::string,long > *) 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 = (std::map< std::string,long > *) 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 jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jint jresult = 0 ;
  std::map< std::string,long > *arg1 = (std::map< std::string,long > *) 0 ;
  std::string *arg2 = 0 ;
  long *result = 0 ;
  
  (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 = (const char *)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 = (long *) &std_map_Sl_std_string_Sc_long_Sg__get(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;
    }
  }
  jresult = (jint)*result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
  std::map< std::string,long > *arg1 = (std::map< std::string,long > *) 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 = (const char *)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__set(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_1erase(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  std::map< std::string,long > *arg1 = (std::map< std::string,long > *) 0 ;
  std::string *arg2 = 0 ;
  
  (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 = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      try {
        std_map_Sl_std_string_Sc_long_Sg__erase(arg1,(std::string const &)*arg2);
      } 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_string_1long_1map_1has_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,long > *arg1 = (std::map< std::string,long > *) 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 = (const char *)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__has_key(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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1long_1map_1keys(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,long > *arg1 = (std::map< std::string,long > *) 0 ;
  std::vector< std::string > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,long > **)&jarg1; 
  {
    try {
      result = std_map_Sl_std_string_Sc_long_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 >((const std::vector< std::string > &)result); 
  return jresult;
}


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 = (std::map< std::string,long > *) 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_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 & reference 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_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = (std::map< std::string,libtorrent::entry > *) 0 ;
  unsigned int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      result = (unsigned int)((std::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_string_1entry_1map_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = (std::map< std::string,libtorrent::entry > *) 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 = (std::map< std::string,libtorrent::entry > *) 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_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jlong jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = (std::map< std::string,libtorrent::entry > *) 0 ;
  std::string *arg2 = 0 ;
  libtorrent::entry *result = 0 ;
  
  (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 = (const char *)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 = (libtorrent::entry *) &std_map_Sl_std_string_Sc_libtorrent_entry_Sg__get(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;
    }
  }
  *(libtorrent::entry **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  std::map< std::string,libtorrent::entry > *arg1 = (std::map< std::string,libtorrent::entry > *) 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 = (const char *)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 & reference is null");
    return ;
  } 
  {
    try {
      std_map_Sl_std_string_Sc_libtorrent_entry_Sg__set(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_1erase(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  std::map< std::string,libtorrent::entry > *arg1 = (std::map< std::string,libtorrent::entry > *) 0 ;
  std::string *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  {
    try {
      try {
        std_map_Sl_std_string_Sc_libtorrent_entry_Sg__erase(arg1,(std::string const &)*arg2);
      } 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_string_1entry_1map_1has_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  jboolean jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = (std::map< std::string,libtorrent::entry > *) 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 = (const char *)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__has_key(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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_string_1entry_1map_1keys(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::map< std::string,libtorrent::entry > *arg1 = (std::map< std::string,libtorrent::entry > *) 0 ;
  std::vector< std::string > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::map< std::string,libtorrent::entry > **)&jarg1; 
  {
    try {
      result = std_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 >((const std::vector< std::string > &)result); 
  return jresult;
}


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 = (std::map< std::string,libtorrent::entry > *) 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1alert_1ptr_1vector(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_alert_1ptr_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::alert * > *arg1 = (std::vector< libtorrent::alert * > *) 0 ;
  std::vector< libtorrent::alert * >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::alert * > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< libtorrent::alert * > *arg1 = (std::vector< libtorrent::alert * > *) 0 ;
  std::vector< libtorrent::alert * >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  {
    try {
      result = ((std::vector< libtorrent::alert * > const *)arg1)->capacity();
    } catch (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_alert_1ptr_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< libtorrent::alert * > *arg1 = (std::vector< libtorrent::alert * > *) 0 ;
  std::vector< libtorrent::alert * >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  arg2 = (std::vector< libtorrent::alert * >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< libtorrent::alert * > *arg1 = (std::vector< libtorrent::alert * > *) 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 = (std::vector< libtorrent::alert * > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< libtorrent::alert * > *arg1 = (std::vector< libtorrent::alert * > *) 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 {
      (arg1)->push_back((std::vector< libtorrent::alert * >::value_type 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_alert_1ptr_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< libtorrent::alert * > *arg1 = (std::vector< libtorrent::alert * > *) 0 ;
  int arg2 ;
  std::vector< libtorrent::alert * >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< libtorrent::alert * > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< libtorrent::alert * >::value_type *) &std_vector_Sl_libtorrent_alert_Sm__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;
    }
  }
  *(std::vector< libtorrent::alert * >::value_type *)&jresult = *result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_alert_1ptr_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< libtorrent::alert * > *arg1 = (std::vector< libtorrent::alert * > *) 0 ;
  int 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 = (int)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__set(arg1,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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1alert_1ptr_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< libtorrent::alert * > *arg1 = (std::vector< libtorrent::alert * > *) 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_1ip_1interface_1vector(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_ip_1interface_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< ip_interface > *arg1 = (std::vector< ip_interface > *) 0 ;
  std::vector< ip_interface >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  {
    try {
      result = ((std::vector< ip_interface > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< ip_interface > *arg1 = (std::vector< ip_interface > *) 0 ;
  std::vector< ip_interface >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  {
    try {
      result = ((std::vector< ip_interface > const *)arg1)->capacity();
    } catch (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_ip_1interface_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< ip_interface > *arg1 = (std::vector< ip_interface > *) 0 ;
  std::vector< ip_interface >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  arg2 = (std::vector< ip_interface >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< ip_interface > *arg1 = (std::vector< ip_interface > *) 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 = (std::vector< ip_interface > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< ip_interface > *arg1 = (std::vector< ip_interface > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< ip_interface >::value_type 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_ip_1interface_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< ip_interface > *arg1 = (std::vector< ip_interface > *) 0 ;
  int arg2 ;
  std::vector< ip_interface >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ip_interface >::value_type *) &std_vector_Sl_ip_interface_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;
    }
  }
  *(std::vector< ip_interface >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1interface_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< ip_interface > *arg1 = (std::vector< ip_interface > *) 0 ;
  int arg2 ;
  std::vector< ip_interface >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< ip_interface > **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< ip_interface >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_interface >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ip_interface_Sg__set(arg1,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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1ip_1interface_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< ip_interface > *arg1 = (std::vector< ip_interface > *) 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(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_ip_1route_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< ip_route > *arg1 = (std::vector< ip_route > *) 0 ;
  std::vector< ip_route >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  {
    try {
      result = ((std::vector< ip_route > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< ip_route > *arg1 = (std::vector< ip_route > *) 0 ;
  std::vector< ip_route >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  {
    try {
      result = ((std::vector< ip_route > const *)arg1)->capacity();
    } catch (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_ip_1route_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< ip_route > *arg1 = (std::vector< ip_route > *) 0 ;
  std::vector< ip_route >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  arg2 = (std::vector< ip_route >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< ip_route > *arg1 = (std::vector< ip_route > *) 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 = (std::vector< ip_route > *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  std::vector< ip_route > *arg1 = (std::vector< ip_route > *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< ip_route >::value_type 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_ip_1route_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  std::vector< ip_route > *arg1 = (std::vector< ip_route > *) 0 ;
  int arg2 ;
  std::vector< ip_route >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< ip_route >::value_type *) &std_vector_Sl_ip_route_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;
    }
  }
  *(std::vector< ip_route >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ip_1route_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jlong jarg3, jobject jarg3_) {
  std::vector< ip_route > *arg1 = (std::vector< ip_route > *) 0 ;
  int arg2 ;
  std::vector< ip_route >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(std::vector< ip_route > **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< ip_route >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_route >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_ip_route_Sg__set(arg1,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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1ip_1route_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< ip_route > *arg1 = (std::vector< ip_route > *) 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_1port_1mapping_1t_1vector(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< port_mapping_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (std::vector< port_mapping_t > *)new std::vector< port_mapping_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< port_mapping_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_port_1mapping_1t_1vector_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< port_mapping_t > *arg1 = (std::vector< port_mapping_t > *) 0 ;
  std::vector< port_mapping_t >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< port_mapping_t > **)&jarg1; 
  {
    try {
      result = ((std::vector< port_mapping_t > 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_port_1mapping_1t_1vector_1capacity(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< port_mapping_t > *arg1 = (std::vector< port_mapping_t > *) 0 ;
  std::vector< port_mapping_t >::size_type result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< port_mapping_t > **)&jarg1; 
  {
    try {
      result = ((std::vector< port_mapping_t > const *)arg1)->capacity();
    } catch (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_port_1mapping_1t_1vector_1reserve(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  std::vector< port_mapping_t > *arg1 = (std::vector< port_mapping_t > *) 0 ;
  std::vector< port_mapping_t >::size_type arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< port_mapping_t > **)&jarg1; 
  arg2 = (std::vector< port_mapping_t >::size_type)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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_port_1mapping_1t_1vector_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  std::vector< port_mapping_t > *arg1 = (std::vector< port_mapping_t > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< port_mapping_t > **)&jarg1; 
  {
    try {
      result = (bool)((std::vector< port_mapping_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_port_1mapping_1t_1vector_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  std::vector< port_mapping_t > *arg1 = (std::vector< port_mapping_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< port_mapping_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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_port_1mapping_1t_1vector_1push_1back(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  std::vector< port_mapping_t > *arg1 = (std::vector< port_mapping_t > *) 0 ;
  std::vector< port_mapping_t >::value_type *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< port_mapping_t > **)&jarg1; 
  arg2 = *(std::vector< port_mapping_t >::value_type **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< port_mapping_t >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->push_back((std::vector< port_mapping_t >::value_type 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 int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_port_1mapping_1t_1vector_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  int jresult = 0 ;
  std::vector< port_mapping_t > *arg1 = (std::vector< port_mapping_t > *) 0 ;
  int arg2 ;
  std::vector< port_mapping_t >::value_type *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< port_mapping_t > **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      try {
        result = (std::vector< port_mapping_t >::value_type *) &std_vector_Sl_port_mapping_t_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;
    }
  }
  *(std::vector< port_mapping_t >::value_type **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_port_1mapping_1t_1vector_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, int jarg3) {
  std::vector< port_mapping_t > *arg1 = (std::vector< port_mapping_t > *) 0 ;
  int arg2 ;
  std::vector< port_mapping_t >::value_type *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(std::vector< port_mapping_t > **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(std::vector< port_mapping_t >::value_type **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< port_mapping_t >::value_type const & reference is null");
    return ;
  } 
  {
    try {
      try {
        std_vector_Sl_port_mapping_t_Sg__set(arg1,arg2,(port_mapping_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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1port_1mapping_1t_1vector(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  std::vector< port_mapping_t > *arg1 = (std::vector< port_mapping_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(std::vector< port_mapping_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 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 = (std::bitset< 96 > *) 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(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (std::bitset< 96 > *) 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 = (std::bitset< 96 > *) 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 = (std::bitset< 96 > *) 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 = (std::bitset< 96 > *) 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 = (std::bitset< 96 > *) 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 = (std::bitset< 96 > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (std::bitset< 96 > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::alert_category_tag > *) 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 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 >((const 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_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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::add_piece_flags_tag > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::status_flags_tag > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::deadline_flags_tag > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::session_flags_tag > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pause_flags_tag > *) 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_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 >((const 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_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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::resume_data_flags_tag > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::picker_flags_tag > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::remove_flags_tag > *) 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_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 >((const 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_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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::save_state_flags_tag > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint64_t,libtorrent::torrent_flags_tag > *) 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 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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::peer_flags_tag > *) 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_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 >((const 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_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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::peer_source_flags_tag > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::pex_flags_tag > *) 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_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 >((const 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_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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::bandwidth_state_flags_tag > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::file_flags_tag > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint32_t,libtorrent::create_flags_tag > *) 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_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 >((const 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_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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reopen_network_flags_tag > *) 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_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 >((const 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_1nonZero(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *arg1 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *) 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *) 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,arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *) 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,arg2);
    } catch (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 >((const 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(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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *) 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,arg2);
    } catch (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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *) 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 >((const 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *) 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_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 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 = (libtorrent::flags::bitfield_flag< std::uint8_t,libtorrent::reannounce_flags_tag > *) 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_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 = (libtorrent::span< char > *) 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 = (libtorrent::span< char > *) 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 = (libtorrent::span< char > *) 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 = (libtorrent::span< char > *) 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 = (libtorrent::span< char > *) 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(arg2);
    } catch (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 >((const 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 = (libtorrent::span< char > *) 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(arg2);
    } catch (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 >((const 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 = (libtorrent::span< char > *) 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(arg2);
    } catch (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 >((const 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 = (libtorrent::span< char > *) 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(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::span< char > **)&jresult = new libtorrent::span< char >((const 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 = (libtorrent::span< char > *) 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,arg2);
    } catch (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 = (libtorrent::span< char > *) 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,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 = (libtorrent::span< char > *) 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 = (libtorrent::span< char const > *) 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 = (libtorrent::span< char const > *) 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 = (libtorrent::span< char const > *) 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 = (libtorrent::span< char const > *) 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 = (libtorrent::span< char const > *) 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(arg2);
    } catch (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 >((const 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 = (libtorrent::span< char const > *) 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(arg2);
    } catch (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 >((const 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 = (libtorrent::span< char const > *) 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(arg2);
    } catch (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 >((const 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 = (libtorrent::span< char const > *) 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(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::span< char const > **)&jresult = new libtorrent::span< char const >((const 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 = (libtorrent::span< char const > *) 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,arg2);
    } catch (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 = (libtorrent::span< char const > *) 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_sha1_1hash_1size(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  size_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::sha1_hash::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::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::sha1_hash *)new libtorrent::sha1_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 = 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::sha1_hash *arg1 = 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::sha1_hash **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & reference is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::sha1_hash *)new libtorrent::sha1_hash((libtorrent::sha1_hash 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::sha1_hash **)&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::sha1_hash result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::sha1_hash::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::sha1_hash **)&jresult = new libtorrent::sha1_hash((const libtorrent::sha1_hash &)result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_sha1_1hash_1min(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::sha1_hash result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent::sha1_hash::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::sha1_hash **)&jresult = new libtorrent::sha1_hash((const libtorrent::sha1_hash &)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::sha1_hash *arg1 = (libtorrent::sha1_hash *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::sha1_hash **)&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::sha1_hash *arg1 = (libtorrent::sha1_hash *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::sha1_hash **)&jarg1; 
  {
    try {
      result = (bool)(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 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::sha1_hash *arg1 = (libtorrent::sha1_hash *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::sha1_hash **)&jarg1; 
  {
    try {
      result = (int)(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_new_1sha1_1hash_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  std::vector< int8_t > *arg1 = 0 ;
  libtorrent::sha1_hash *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 & reference is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::sha1_hash *)new_libtorrent_sha1_hash__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::sha1_hash **)&jresult = result; 
  return jresult;
}


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::sha1_hash *arg1 = (libtorrent::sha1_hash *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::sha1_hash **)&jarg1; 
  {
    try {
      result = (int)libtorrent_sha1_hash_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::sha1_hash *arg1 = (libtorrent::sha1_hash *) 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::sha1_hash **)&jarg1; 
  {
    try {
      result = libtorrent_sha1_hash_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 >((const std::vector< 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::sha1_hash *arg1 = (libtorrent::sha1_hash *) 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::sha1_hash **)&jarg1; 
  {
    try {
      result = libtorrent_sha1_hash_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 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::sha1_hash *arg1 = (libtorrent::sha1_hash *) 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::sha1_hash **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)libtorrent_sha1_hash_op_eq((libtorrent::sha1_hash const *)arg1,(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 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::sha1_hash *arg1 = (libtorrent::sha1_hash *) 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::sha1_hash **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)libtorrent_sha1_hash_op_ne((libtorrent::sha1_hash const *)arg1,(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 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::sha1_hash *arg1 = (libtorrent::sha1_hash *) 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::sha1_hash **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)libtorrent_sha1_hash_op_lt((libtorrent::sha1_hash const *)arg1,(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 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::sha1_hash *arg1 = 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::sha1_hash **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & reference is null");
    return 0;
  } 
  arg2 = *(libtorrent::sha1_hash **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & reference is null");
    return 0;
  } 
  {
    try {
      result = (int)libtorrent_sha1_hash_compare((libtorrent::sha1_hash const &)*arg1,(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 = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1sha1_1hash(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::sha1_hash *arg1 = (libtorrent::sha1_hash *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::sha1_hash **)&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_1128_1find(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::bloom_filter< 128 > *arg1 = (libtorrent::bloom_filter< 128 > *) 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 & reference 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 = (libtorrent::bloom_filter< 128 > *) 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 & reference 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 = (libtorrent::bloom_filter< 128 > *) 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 = (libtorrent::bloom_filter< 128 > *) 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 = (libtorrent::bloom_filter< 128 > *) 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 >((const 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 = (libtorrent::bloom_filter< 128 > *) 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 & reference 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 = (libtorrent::bloom_filter< 128 > *) 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 = (libtorrent::bloom_filter< 256 > *) 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 & reference 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 = (libtorrent::bloom_filter< 256 > *) 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 & reference 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 = (libtorrent::bloom_filter< 256 > *) 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 = (libtorrent::bloom_filter< 256 > *) 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 = (libtorrent::bloom_filter< 256 > *) 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 >((const 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 = (libtorrent::bloom_filter< 256 > *) 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 & reference 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 = (libtorrent::bloom_filter< 256 > *) 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_string_1view_1to_1bytes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::string_view *arg1 = (libtorrent::string_view *) 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 >((const 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 = (libtorrent::string_view *) 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_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 & reference 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 = (libtorrent::address *) 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 = (libtorrent::address *) 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_, jlong jarg2, jobject jarg2_) {
  jstring jresult = 0 ;
  libtorrent::address *arg1 = (libtorrent::address *) 0 ;
  boost::system::error_code arg2 ;
  boost::system::error_code *argp2 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::address **)&jarg1; 
  argp2 = *(boost::system::error_code **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null boost::system::error_code");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (arg1)->to_string(arg2);
    } catch (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 = (libtorrent::address *) 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 = (libtorrent::address *) 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 = (libtorrent::address *) 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 = (libtorrent::address *) 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 & reference 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 & reference is null");
    return 0;
  } 
  arg2 = *(libtorrent::address **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::address const & reference 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 = (const char *)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 & reference 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((const libtorrent::address &)result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1address(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::address *arg1 = (libtorrent::address *) 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(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 & reference 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 = (libtorrent::tcp::endpoint *) 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 = (libtorrent::tcp::endpoint *) 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((const 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 = (libtorrent::tcp::endpoint *) 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(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 & reference 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 = (libtorrent::udp::endpoint *) 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 = (libtorrent::udp::endpoint *) 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((const 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 = (libtorrent::udp::endpoint *) 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 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 = (libtorrent::entry *) 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(arg1);
    } catch (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, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::span< char const > arg1 ;
  libtorrent::span< char const > *argp1 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(libtorrent::span< char const > **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::span< char const >");
    return 0;
  }
  arg1 = *argp1; 
  {
    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_12(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 = (const char *)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(arg1);
    } catch (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, 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(arg1);
    } catch (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, 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_15(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_16(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 & reference 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_17(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 = (libtorrent::entry *) 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 = (libtorrent::entry *) 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 = (libtorrent::entry *) 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 = (libtorrent::entry *) 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_entry_1find_1key(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::entry *arg1 = (libtorrent::entry *) 0 ;
  libtorrent::string_view arg2 ;
  libtorrent::string_view *argp2 ;
  libtorrent::entry *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::entry **)&jarg1; 
  argp2 = *(libtorrent::string_view **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (libtorrent::entry *)(arg1)->find_key(arg2);
    } catch (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 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 = (libtorrent::entry *) 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 = (libtorrent::entry *) 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 = (const char *)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 = (libtorrent::entry *) 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 = (const char *)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 = (const char *)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 = (libtorrent::entry *) 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 = (const char *)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 & reference 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 = (libtorrent::entry *) 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 = (const char *)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 = (libtorrent::entry *) 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 = (const char *)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 & reference 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 = (libtorrent::entry *) 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 >((const 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 = (libtorrent::entry *) 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 >((const 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 = (libtorrent::entry *) 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 >((const 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 & reference 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((const 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 & reference 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((const 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 > & reference 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((const 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 = (libtorrent::entry *) 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_new_1piece_1index_1bitfield_1_1SWIG_10(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::typed_bitfield< piece_index_t > *)new libtorrent::typed_bitfield< 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;
    }
  }
  *(libtorrent::typed_bitfield< piece_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1bitfield_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  int arg1 ;
  libtorrent::typed_bitfield< piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = (libtorrent::typed_bitfield< piece_index_t > *)new libtorrent::typed_bitfield< piece_index_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::typed_bitfield< piece_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1bitfield_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jint jarg1, jboolean jarg2) {
  jlong jresult = 0 ;
  int arg1 ;
  bool arg2 ;
  libtorrent::typed_bitfield< piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try {
      result = (libtorrent::typed_bitfield< piece_index_t > *)new libtorrent::typed_bitfield< piece_index_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;
    }
  }
  *(libtorrent::typed_bitfield< piece_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1piece_1index_1bitfield_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg1 = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::typed_bitfield< piece_index_t > const & reference is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::typed_bitfield< piece_index_t > *)new libtorrent::typed_bitfield< piece_index_t >((libtorrent::typed_bitfield< 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;
    }
  }
  *(libtorrent::typed_bitfield< piece_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1bitfield_1get_1bit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jboolean jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  piece_index_t arg2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  {
    try {
      result = (bool)((libtorrent::typed_bitfield< piece_index_t > 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_piece_1index_1bitfield_1clear_1bit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  piece_index_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(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_piece_1index_1bitfield_1set_1bit(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  piece_index_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(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 int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1bitfield_1end_1index(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  piece_index_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    try {
      result = ((libtorrent::typed_bitfield< piece_index_t > const *)arg1)->end_index();
    } catch (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_piece_1index_1bitfield_1all_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::typed_bitfield< piece_index_t > 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_piece_1index_1bitfield_1none_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::typed_bitfield< piece_index_t > 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_piece_1index_1bitfield_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::typed_bitfield< piece_index_t > 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_piece_1index_1bitfield_1num_1words(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::typed_bitfield< piece_index_t > 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_piece_1index_1bitfield_1empty(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::typed_bitfield< 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 jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_piece_1index_1bitfield_1count(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::typed_bitfield< piece_index_t > 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_piece_1index_1bitfield_1find_1first_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::typed_bitfield< piece_index_t > 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_piece_1index_1bitfield_1find_1last_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::typed_bitfield< piece_index_t > 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_piece_1index_1bitfield_1resize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jboolean jarg3) {
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  int arg2 ;
  bool arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&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_piece_1index_1bitfield_1resize_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&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_piece_1index_1bitfield_1set_1all(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&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_piece_1index_1bitfield_1clear_1all(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< piece_index_t > **)&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_piece_1index_1bitfield_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::typed_bitfield< 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1piece_1index_1bitfield(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::typed_bitfield< piece_index_t > *arg1 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::typed_bitfield< 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 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (const char *)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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 = (libtorrent::peer_class_info *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1last_1error_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  libtorrent::error_code *arg2 = (libtorrent::error_code *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  arg2 = *(libtorrent::error_code **)&jarg2; 
  if (arg1) (arg1)->last_error = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1last_1error_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  libtorrent::error_code *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&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_1endpoint_1local_1endpoint_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  libtorrent::tcp::endpoint *arg2 = (libtorrent::tcp::endpoint *) 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 = (libtorrent::announce_endpoint *) 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_1scrape_1incomplete_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->scrape_incomplete = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1scrape_1incomplete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  result = (int) ((arg1)->scrape_incomplete);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1scrape_1complete_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->scrape_complete = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1scrape_1complete_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  result = (int) ((arg1)->scrape_complete);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1scrape_1downloaded_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->scrape_downloaded = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1scrape_1downloaded_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  result = (int) ((arg1)->scrape_downloaded);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1fails_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jshort jarg2) {
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  std::uint8_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  arg2 = (std::uint8_t)jarg2; 
  if (arg1) (arg1)->fails = arg2;
}


SWIGEXPORT jshort JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1fails_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jshort jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  std::uint8_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  result = (std::uint8_t) ((arg1)->fails);
  jresult = (jshort)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1updating_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->updating = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1updating_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  result = (bool) ((arg1)->updating);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1is_1working(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::announce_endpoint const *)arg1)->is_working();
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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_announce_1endpoint_1get_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  std::vector< int8_t > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  {
    try {
      result = libtorrent_announce_endpoint_get_message(arg1);
    } catch (std::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 >((const std::vector< int8_t > &)result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_announce_1endpoint_1get_1next_1announce(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_announce_endpoint_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_1endpoint_1get_1min_1announce(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::announce_endpoint **)&jarg1; 
  {
    try {
      result = (int64_t)libtorrent_announce_endpoint_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_1endpoint(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::announce_endpoint *arg1 = (libtorrent::announce_endpoint *) 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 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 = (libtorrent::announce_entry *) 0 ;
  std::vector< libtorrent::announce_endpoint > *arg2 = (std::vector< libtorrent::announce_endpoint > *) 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 = (libtorrent::announce_entry *) 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 = (libtorrent::announce_entry *) 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 = (libtorrent::announce_entry *) 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 = (libtorrent::announce_entry *) 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 = (libtorrent::announce_entry *) 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 = (libtorrent::announce_entry *) 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 = (libtorrent::announce_entry *) 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 = (libtorrent::announce_entry *) 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 = (libtorrent::announce_entry *) 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(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 & reference is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::announce_entry *)new_libtorrent_announce_entry((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 = (libtorrent::announce_entry *) 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 >((const 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 = (libtorrent::announce_entry *) 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 & reference 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 = (libtorrent::announce_entry *) 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 >((const 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 = (libtorrent::announce_entry *) 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 & reference 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_delete_1announce_1entry(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::announce_entry *arg1 = (libtorrent::announce_entry *) 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 jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_success_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::success;
    } catch (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_address_1family_1not_1supported_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::address_family_not_supported;
    } catch (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_address_1in_1use_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::address_in_use;
    } catch (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_address_1not_1available_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::address_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_already_1connected_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::already_connected;
    } catch (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_argument_1list_1too_1long_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::argument_list_too_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;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_argument_1out_1of_1domain_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::argument_out_of_domain;
    } catch (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_1address_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::bad_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;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bad_1file_1descriptor_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::bad_file_descriptor;
    } catch (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_1message_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::bad_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 = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_broken_1pipe_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::broken_pipe;
    } catch (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_connection_1aborted_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::connection_aborted;
    } catch (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_connection_1already_1in_1progress_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::connection_already_in_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;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_connection_1refused_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::connection_refused;
    } catch (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_connection_1reset_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::connection_reset;
    } catch (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_cross_1device_1link_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::cross_device_link;
    } catch (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_destination_1address_1required_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::destination_address_required;
    } catch (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_device_1or_1resource_1busy_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::device_or_resource_busy;
    } catch (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_directory_1not_1empty_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::directory_not_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 = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_executable_1format_1error_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::executable_format_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_file_1exists_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::file_exists;
    } catch (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_1too_1large_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::file_too_large;
    } catch (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_filename_1too_1long_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::filename_too_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;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_function_1not_1supported_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::function_not_supported;
    } catch (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_host_1unreachable_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::host_unreachable;
    } catch (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_identifier_1removed_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::identifier_removed;
    } catch (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_illegal_1byte_1sequence_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::illegal_byte_sequence;
    } catch (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_inappropriate_1io_1control_1operation_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::inappropriate_io_control_operation;
    } catch (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_interrupted_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::interrupted;
    } catch (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_invalid_1argument_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::invalid_argument;
    } catch (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_invalid_1seek_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::invalid_seek;
    } catch (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_io_1error_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::io_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_is_1a_1directory_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::is_a_directory;
    } catch (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_message_1size_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::message_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_network_1down_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::network_down;
    } catch (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_network_1reset_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::network_reset;
    } catch (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_network_1unreachable_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::network_unreachable;
    } catch (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_1buffer_1space_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_buffer_space;
    } catch (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_1child_1process_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_child_process;
    } catch (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_1link_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_link;
    } catch (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_1lock_1available_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_lock_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_1message_1available_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_message_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_1message_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_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 = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_no_1protocol_1option_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_protocol_option;
    } catch (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_1space_1on_1device_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_space_on_device;
    } catch (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_1stream_1resources_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_stream_resources;
    } catch (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_1such_1device_1or_1address_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_such_device_or_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;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_no_1such_1device_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_such_device;
    } catch (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_1such_1file_1or_1directory_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_such_file_or_directory;
    } catch (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_1such_1process_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::no_such_process;
    } catch (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_1a_1directory_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::not_a_directory;
    } catch (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_1a_1socket_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::not_a_socket;
    } catch (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_1a_1stream_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::not_a_stream;
    } catch (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_1connected_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::not_connected;
    } catch (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_1enough_1memory_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::not_enough_memory;
    } catch (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_1supported_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::not_supported;
    } catch (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_operation_1canceled_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::operation_canceled;
    } catch (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_operation_1in_1progress_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::operation_in_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;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_operation_1not_1permitted_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::operation_not_permitted;
    } catch (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_operation_1not_1supported_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::operation_not_supported;
    } catch (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_operation_1would_1block_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::operation_would_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;
    }
  }
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_owner_1dead_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::owner_dead;
    } catch (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_permission_1denied_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::permission_denied;
    } catch (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_protocol_1error_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::protocol_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_protocol_1not_1supported_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::protocol_not_supported;
    } catch (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_read_1only_1file_1system_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::read_only_file_system;
    } catch (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_resource_1deadlock_1would_1occur_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::resource_deadlock_would_occur;
    } catch (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_resource_1unavailable_1try_1again_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::resource_unavailable_try_again;
    } catch (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_result_1out_1of_1range_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::result_out_of_range;
    } catch (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_state_1not_1recoverable_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::state_not_recoverable;
    } catch (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_stream_1timeout_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::stream_timeout;
    } catch (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_text_1file_1busy_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::text_file_busy;
    } catch (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_timed_1out_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::timed_out;
    } catch (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_too_1many_1files_1open_1in_1system_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::too_many_files_open_in_system;
    } catch (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_too_1many_1files_1open_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::too_many_files_open;
    } catch (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_too_1many_1links_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::too_many_links;
    } catch (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_too_1many_1symbolic_1link_1levels_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::too_many_symbolic_link_levels;
    } catch (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_value_1too_1large_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::value_too_large;
    } catch (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_wrong_1protocol_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  boost::system::errc::errc_t result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::errc::errc_t)boost::system::errc::wrong_protocol_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_1generic_1error_1category(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  boost::system::detail::generic_error_category *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::detail::generic_error_category *)new boost::system::detail::generic_error_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;
    }
  }
  *(boost::system::detail::generic_error_category **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_generic_1error_1category_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  boost::system::detail::generic_error_category *arg1 = (boost::system::detail::generic_error_category *) 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::detail::generic_error_category **)&jarg1; 
  {
    try {
      result = (char *)((boost::system::detail::generic_error_category 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;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_generic_1error_1category_1message_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jstring jresult = 0 ;
  boost::system::detail::generic_error_category *arg1 = (boost::system::detail::generic_error_category *) 0 ;
  int arg2 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::detail::generic_error_category **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = ((boost::system::detail::generic_error_category const *)arg1)->message(arg2);
    } catch (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_generic_1error_1category_1message_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3, jlong jarg4) {
  jstring jresult = 0 ;
  boost::system::detail::generic_error_category *arg1 = (boost::system::detail::generic_error_category *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  std::size_t arg4 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::detail::generic_error_category **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = 0;
  if (jarg3) {
    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
    if (!arg3) return 0;
  }
  arg4 = (std::size_t)jarg4; 
  {
    try {
      result = (char *)((boost::system::detail::generic_error_category const *)arg1)->message(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;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1generic_1error_1category(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  boost::system::detail::generic_error_category *arg1 = (boost::system::detail::generic_error_category *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(boost::system::detail::generic_error_category **)&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_1system_1error_1category(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  boost::system::detail::system_error_category *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (boost::system::detail::system_error_category *)new boost::system::detail::system_error_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;
    }
  }
  *(boost::system::detail::system_error_category **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_system_1error_1category_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  boost::system::detail::system_error_category *arg1 = (boost::system::detail::system_error_category *) 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::detail::system_error_category **)&jarg1; 
  {
    try {
      result = (char *)((boost::system::detail::system_error_category 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;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_system_1error_1category_1default_1error_1condition(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  boost::system::detail::system_error_category *arg1 = (boost::system::detail::system_error_category *) 0 ;
  int arg2 ;
  boost::system::error_condition result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::detail::system_error_category **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = ((boost::system::detail::system_error_category const *)arg1)->default_error_condition(arg2);
    } 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_condition **)&jresult = new boost::system::error_condition((const boost::system::error_condition &)result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_system_1error_1category_1message_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jstring jresult = 0 ;
  boost::system::detail::system_error_category *arg1 = (boost::system::detail::system_error_category *) 0 ;
  int arg2 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::detail::system_error_category **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = ((boost::system::detail::system_error_category const *)arg1)->message(arg2);
    } catch (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_system_1error_1category_1message_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jstring jarg3, jlong jarg4) {
  jstring jresult = 0 ;
  boost::system::detail::system_error_category *arg1 = (boost::system::detail::system_error_category *) 0 ;
  int arg2 ;
  char *arg3 = (char *) 0 ;
  std::size_t arg4 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::detail::system_error_category **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = 0;
  if (jarg3) {
    arg3 = (char *)jenv->GetStringUTFChars(jarg3, 0);
    if (!arg3) return 0;
  }
  arg4 = (std::size_t)jarg4; 
  {
    try {
      result = (char *)((boost::system::detail::system_error_category const *)arg1)->message(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;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  if (arg3) jenv->ReleaseStringUTFChars(jarg3, (const char *)arg3);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1system_1error_1category(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  boost::system::detail::system_error_category *arg1 = (boost::system::detail::system_error_category *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(boost::system::detail::system_error_category **)&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_failed_1impl(JNIEnv *jenv, jclass jcls, jint jarg1, jlong jarg2) {
  jboolean jresult = 0 ;
  int arg1 ;
  boost::system::error_category *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  arg2 = *(boost::system::error_category **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "boost::system::error_category const & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)boost::system::detail::failed_impl(arg1,(boost::system::error_category 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_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 = (boost::system::error_code *) 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 = (boost::system::error_code *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::error_code **)&jarg1; 
  {
    try {
      result = (int)((boost::system::error_code const *)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_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  boost::system::error_code *arg1 = (boost::system::error_code *) 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::error_code **)&jarg1; 
  {
    try {
      result = ((boost::system::error_code 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_error_1code_1message_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3) {
  jstring jresult = 0 ;
  boost::system::error_code *arg1 = (boost::system::error_code *) 0 ;
  char *arg2 = (char *) 0 ;
  std::size_t arg3 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::error_code **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  arg3 = (std::size_t)jarg3; 
  {
    try {
      result = (char *)((boost::system::error_code const *)arg1)->message(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;
    }
  }
  if (result) jresult = jenv->NewStringUTF((const char *)result);
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  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 = (boost::system::error_code *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(boost::system::error_code **)&jarg1; 
  {
    try {
      result = (bool)((boost::system::error_code 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_error_1code_1op_1bool(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  boost::system::error_code *arg1 = (boost::system::error_code *) 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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_op_1eq_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  boost::system::error_code *arg1 = 0 ;
  boost::system::error_code *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(boost::system::error_code **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "boost::system::error_code const & reference is null");
    return 0;
  } 
  arg2 = *(boost::system::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "boost::system::error_code const & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)operator ==((boost::system::error_code const &)*arg1,(boost::system::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_op_1lt_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  boost::system::error_code *arg1 = 0 ;
  boost::system::error_code *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(boost::system::error_code **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "boost::system::error_code const & reference is null");
    return 0;
  } 
  arg2 = *(boost::system::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "boost::system::error_code const & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)operator <((boost::system::error_code const &)*arg1,(boost::system::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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1error_1code(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  boost::system::error_code *arg1 = (boost::system::error_code *) 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 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 ;
  boost::system::error_code *arg1 = 0 ;
  boost::system::error_code *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(boost::system::error_code **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "boost::system::error_code const & reference is null");
    return 0;
  } 
  arg2 = *(boost::system::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "boost::system::error_code const & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)boost::system::operator !=((boost::system::error_code const &)*arg1,(boost::system::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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_make_1error_1code(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jlong jresult = 0 ;
  boost::system::errc::errc_t arg1 ;
  boost::system::error_code result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (boost::system::errc::errc_t)jarg1; 
  {
    try {
      result = boost::system::errc::make_error_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;
    }
  }
  *(boost::system::error_code **)&jresult = new boost::system::error_code((const boost::system::error_code &)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)(1);
  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)(2);
  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)(12);
  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)(((1*10000) +(2*100) +12));
  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 *)("1.2.12.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 *)("2d3870c18");
  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 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_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 & reference 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_peer_1request_1piece_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::peer_request *arg1 = (libtorrent::peer_request *) 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 = (libtorrent::peer_request *) 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 = (libtorrent::peer_request *) 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 = (libtorrent::peer_request *) 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 = (libtorrent::peer_request *) 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 = (libtorrent::peer_request *) 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 = (libtorrent::peer_request *) 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 & reference 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 = (libtorrent::peer_request *) 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 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 = (libtorrent::file_slice *) 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 = (libtorrent::file_slice *) 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 = (libtorrent::file_slice *) 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 = (libtorrent::file_slice *) 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 = (libtorrent::file_slice *) 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 = (libtorrent::file_slice *) 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 = (libtorrent::file_slice *) 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 = (libtorrent::file_storage *) 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 & reference 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 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 = (libtorrent::file_storage *) 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 = (libtorrent::file_storage *) 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_1add_1file_1borrow_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jlong jarg4, jlong jarg5, jobject jarg5_, jstring jarg6, jlong jarg7, jlong jarg8, jobject jarg8_) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  libtorrent::string_view arg2 ;
  std::string *arg3 = 0 ;
  std::int64_t arg4 ;
  libtorrent::file_flags_t arg5 ;
  char *arg6 = (char *) 0 ;
  std::int64_t arg7 ;
  libtorrent::string_view arg8 ;
  libtorrent::string_view *argp2 ;
  libtorrent::file_flags_t *argp5 ;
  libtorrent::string_view *argp8 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg5_;
  (void)jarg8_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  argp2 = *(libtorrent::string_view **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return ;
  }
  arg2 = *argp2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = (const char *)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 = 0;
  if (jarg6) {
    arg6 = (char *)jenv->GetStringUTFChars(jarg6, 0);
    if (!arg6) return ;
  }
  arg7 = (std::int64_t)jarg7; 
  argp8 = *(libtorrent::string_view **)&jarg8; 
  if (!argp8) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return ;
  }
  arg8 = *argp8; 
  {
    try {
      (arg1)->add_file_borrow(arg2,(std::string const &)*arg3,arg4,arg5,(char const *)arg6,arg7,arg8);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
  if (arg6) jenv->ReleaseStringUTFChars(jarg6, (const char *)arg6);
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1add_1file_1borrow_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jlong jarg4, jlong jarg5, jobject jarg5_, jstring jarg6, jlong jarg7) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  libtorrent::string_view arg2 ;
  std::string *arg3 = 0 ;
  std::int64_t arg4 ;
  libtorrent::file_flags_t arg5 ;
  char *arg6 = (char *) 0 ;
  std::int64_t arg7 ;
  libtorrent::string_view *argp2 ;
  libtorrent::file_flags_t *argp5 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg5_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  argp2 = *(libtorrent::string_view **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return ;
  }
  arg2 = *argp2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = (const char *)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 = 0;
  if (jarg6) {
    arg6 = (char *)jenv->GetStringUTFChars(jarg6, 0);
    if (!arg6) return ;
  }
  arg7 = (std::int64_t)jarg7; 
  {
    try {
      (arg1)->add_file_borrow(arg2,(std::string const &)*arg3,arg4,arg5,(char const *)arg6,arg7);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
  if (arg6) jenv->ReleaseStringUTFChars(jarg6, (const char *)arg6);
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1add_1file_1borrow_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jlong jarg4, jlong jarg5, jobject jarg5_, jstring jarg6) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  libtorrent::string_view arg2 ;
  std::string *arg3 = 0 ;
  std::int64_t arg4 ;
  libtorrent::file_flags_t arg5 ;
  char *arg6 = (char *) 0 ;
  libtorrent::string_view *argp2 ;
  libtorrent::file_flags_t *argp5 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg5_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  argp2 = *(libtorrent::string_view **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return ;
  }
  arg2 = *argp2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = (const char *)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 = 0;
  if (jarg6) {
    arg6 = (char *)jenv->GetStringUTFChars(jarg6, 0);
    if (!arg6) return ;
  }
  {
    try {
      (arg1)->add_file_borrow(arg2,(std::string const &)*arg3,arg4,arg5,(char const *)arg6);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, e.what());
      return ;
    } catch (...) {
      SWIG_JavaThrowException(jenv, SWIG_JavaRuntimeException, "Unknown exception type");
      return ;
    }
  }
  if (arg6) jenv->ReleaseStringUTFChars(jarg6, (const char *)arg6);
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1add_1file_1borrow_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jlong jarg4, jlong jarg5, jobject jarg5_) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  libtorrent::string_view arg2 ;
  std::string *arg3 = 0 ;
  std::int64_t arg4 ;
  libtorrent::file_flags_t arg5 ;
  libtorrent::string_view *argp2 ;
  libtorrent::file_flags_t *argp5 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg5_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  argp2 = *(libtorrent::string_view **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return ;
  }
  arg2 = *argp2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = (const char *)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 {
      (arg1)->add_file_borrow(arg2,(std::string const &)*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_file_1storage_1add_1file_1borrow_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jstring jarg3, jlong jarg4) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  libtorrent::string_view arg2 ;
  std::string *arg3 = 0 ;
  std::int64_t arg4 ;
  libtorrent::string_view *argp2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  argp2 = *(libtorrent::string_view **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return ;
  }
  arg2 = *argp2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg3_pstr = (const char *)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 {
      (arg1)->add_file_borrow(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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1add_1file_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jlong jarg4, jobject jarg4_, jlong jarg5, jlong jarg6, jobject jarg6_) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  std::string *arg2 = 0 ;
  std::int64_t arg3 ;
  libtorrent::file_flags_t arg4 ;
  std::time_t arg5 ;
  libtorrent::string_view arg6 ;
  libtorrent::file_flags_t *argp4 ;
  libtorrent::string_view *argp6 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg4_;
  (void)jarg6_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = (std::int64_t)jarg3; 
  argp4 = *(libtorrent::file_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::file_flags_t");
    return ;
  }
  arg4 = *argp4; 
  arg5 = (std::time_t)jarg5; 
  argp6 = *(libtorrent::string_view **)&jarg6; 
  if (!argp6) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return ;
  }
  arg6 = *argp6; 
  {
    try {
      (arg1)->add_file((std::string const &)*arg2,arg3,arg4,arg5,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_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jlong jarg4, jobject jarg4_, jlong jarg5) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  std::string *arg2 = 0 ;
  std::int64_t arg3 ;
  libtorrent::file_flags_t arg4 ;
  std::time_t arg5 ;
  libtorrent::file_flags_t *argp4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg4_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = (std::int64_t)jarg3; 
  argp4 = *(libtorrent::file_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::file_flags_t");
    return ;
  }
  arg4 = *argp4; 
  arg5 = (std::time_t)jarg5; 
  {
    try {
      (arg1)->add_file((std::string const &)*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_file_1storage_1add_1file_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jlong jarg4, jobject jarg4_) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  std::string *arg2 = 0 ;
  std::int64_t arg3 ;
  libtorrent::file_flags_t arg4 ;
  libtorrent::file_flags_t *argp4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg4_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = (std::int64_t)jarg3; 
  argp4 = *(libtorrent::file_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::file_flags_t");
    return ;
  }
  arg4 = *argp4; 
  {
    try {
      (arg1)->add_file((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_file_1storage_1add_1file_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  std::string *arg2 = 0 ;
  std::int64_t arg3 ;
  
  (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 = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = (std::int64_t)jarg3; 
  {
    try {
      (arg1)->add_file((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_file_1storage_1rename_1file(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jstring jarg3) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 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 = (const char *)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(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, jint jarg4) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 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::file_storage **)&jarg1; 
  {
    arg2 = piece_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = (std::int64_t)jarg3; 
  arg4 = (int)jarg4; 
  {
    try {
      result = ((libtorrent::file_storage const *)arg1)->map_block(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 >((const 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 = (libtorrent::file_storage *) 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(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((const 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 = (libtorrent::file_storage *) 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 = (libtorrent::file_storage *) 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 = (libtorrent::file_storage *) 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 = (libtorrent::file_storage *) 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 = (libtorrent::file_storage *) 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 = (libtorrent::file_storage *) 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 = (libtorrent::file_storage *) 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 = (libtorrent::file_storage *) 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 = (libtorrent::file_storage *) 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 = (libtorrent::file_storage *) 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(arg2);
    } catch (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 = (libtorrent::file_storage *) 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 = (const char *)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 = (libtorrent::file_storage *) 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 = (libtorrent::file_storage *) 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 & reference 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_1optimize_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jboolean jarg4) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  int arg2 ;
  int arg3 ;
  bool arg4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  arg4 = jarg4 ? true : false; 
  {
    try {
      (arg1)->optimize(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_file_1storage_1optimize_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  int arg2 ;
  int arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      (arg1)->optimize(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_file_1storage_1optimize_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      (arg1)->optimize(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_1optimize_1_1SWIG_13(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      (arg1)->optimize();
    } 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 = (libtorrent::file_storage *) 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(arg2);
    } catch (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((const libtorrent::sha1_hash &)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 = (libtorrent::file_storage *) 0 ;
  file_index_t arg2 ;
  std::string *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 = (std::string *) &((libtorrent::file_storage const *)arg1)->symlink(arg2);
    } catch (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 = (libtorrent::file_storage *) 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(arg2);
    } catch (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 = (libtorrent::file_storage *) 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 = (const char *)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(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 = (libtorrent::file_storage *) 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(arg2);
    } catch (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_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  file_index_t arg2 ;
  libtorrent::string_view 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_name(arg2);
    } catch (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 = new libtorrent::string_view((const libtorrent::string_view &)result); 
  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 = (libtorrent::file_storage *) 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(arg2);
    } catch (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 = (libtorrent::file_storage *) 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(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::file_storage *) 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(arg2);
    } catch (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_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_1paths(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  std::vector< std::string > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  {
    try {
      result = (std::vector< std::string > *) &((libtorrent::file_storage const *)arg1)->paths();
    } catch (std::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_file_1storage_1file_1flags(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 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(arg2);
    } catch (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((const 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 = (libtorrent::file_storage *) 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(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::file_storage *) 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 jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_file_1storage_1internal_1symlink(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jstring jresult = 0 ;
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  file_index_t arg2 ;
  std::string *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 = (std::string *) &((libtorrent::file_storage const *)arg1)->internal_symlink(arg2);
    } catch (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_1add_1file_1_1SWIG_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jlong jarg4, jobject jarg4_, jlong jarg5, jstring jarg6) {
  libtorrent::file_storage *arg1 = (libtorrent::file_storage *) 0 ;
  std::string *arg2 = 0 ;
  std::int64_t arg3 ;
  libtorrent::file_flags_t arg4 ;
  std::time_t arg5 ;
  std::string *arg6 = 0 ;
  libtorrent::file_flags_t *argp4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg4_;
  arg1 = *(libtorrent::file_storage **)&jarg1; 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = (std::int64_t)jarg3; 
  argp4 = *(libtorrent::file_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::file_flags_t");
    return ;
  }
  arg4 = *argp4; 
  arg5 = (std::time_t)jarg5; 
  if(!jarg6) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg6_pstr = (const char *)jenv->GetStringUTFChars(jarg6, 0); 
  if (!arg6_pstr) return ;
  std::string arg6_str(arg6_pstr);
  arg6 = &arg6_str;
  jenv->ReleaseStringUTFChars(jarg6, arg6_pstr); 
  {
    try {
      libtorrent_file_storage_add_file__SWIG_4(arg1,(std::string const &)*arg2,arg3,arg4,arg5,(std::string const &)*arg6);
    } 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 & reference 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 = (libtorrent::bdecode_node *) 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 = (libtorrent::bdecode_node *) 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_1list_1at(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = (libtorrent::bdecode_node *) 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((const 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 = (libtorrent::bdecode_node *) 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 = (libtorrent::bdecode_node *) 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 = (libtorrent::bdecode_node *) 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(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jlong jresult = 0 ;
  libtorrent::bdecode_node *arg1 = (libtorrent::bdecode_node *) 0 ;
  int arg2 ;
  std::pair< libtorrent::string_view,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(arg2);
    } catch (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 = new std::pair< libtorrent::string_view,libtorrent::bdecode_node >((const std::pair< libtorrent::string_view,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 = (libtorrent::bdecode_node *) 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 = (libtorrent::bdecode_node *) 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 = (libtorrent::bdecode_node *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_bdecode_1node_1clear(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::bdecode_node *arg1 = (libtorrent::bdecode_node *) 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 = (libtorrent::bdecode_node *) 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 = (const char *)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,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 = (libtorrent::bdecode_node *) 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 = (libtorrent::bdecode_node *) 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 = (const char *)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,arg2);
    } catch (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((const 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 = (libtorrent::bdecode_node *) 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 = (const char *)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,arg2);
    } catch (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((const 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 = (libtorrent::bdecode_node *) 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 = (const char *)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,arg2);
    } catch (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((const 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 = (libtorrent::bdecode_node *) 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 = (const char *)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,arg2);
    } catch (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((const 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 = (libtorrent::bdecode_node *) 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 = (const char *)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,arg2);
    } catch (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((const 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 = (libtorrent::bdecode_node *) 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 = (const char *)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 = (const char *)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,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_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 = (libtorrent::bdecode_node *) 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 = (const char *)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,arg2);
    } catch (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 = (libtorrent::bdecode_node *) 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 = (const char *)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,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 = (libtorrent::bdecode_node *) 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 = (const char *)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,arg2);
    } catch (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 = (libtorrent::bdecode_node *) 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_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 & reference 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 > & reference is null");
    return 0;
  } 
  arg2 = *(libtorrent::bdecode_node **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node & reference is null");
    return 0;
  } 
  arg3 = *(libtorrent::error_code **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & reference 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 = (libtorrent::bdecode_node *) 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_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 = (libtorrent::peer_info *) 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 & reference 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_1pieces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::peer_info *arg1 = (libtorrent::peer_info *) 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg2 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg2; 
  if (arg1) (arg1)->pieces = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1pieces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::peer_info *arg1 = (libtorrent::peer_info *) 0 ;
  libtorrent::typed_bitfield< piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (libtorrent::typed_bitfield< piece_index_t > *)& ((arg1)->pieces);
  *(libtorrent::typed_bitfield< piece_index_t > **)&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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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_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 = (libtorrent::peer_info *) 0 ;
  libtorrent::peer_flags_t *arg2 = (libtorrent::peer_flags_t *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 0 ;
  libtorrent::peer_source_flags_t *arg2 = (libtorrent::peer_source_flags_t *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 0 ;
  libtorrent::peer_id *arg2 = (libtorrent::peer_id *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1standard_1bittorrent_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::peer_info::connection_type_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::peer_info::connection_type_t)libtorrent::peer_info::standard_bittorrent;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1web_1seed_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::peer_info::connection_type_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::peer_info::connection_type_t)libtorrent::peer_info::web_seed;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1http_1seed_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::peer_info::connection_type_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::peer_info::connection_type_t)libtorrent::peer_info::http_seed;
  jresult = (jint)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_, jint jarg2) {
  libtorrent::peer_info *arg1 = (libtorrent::peer_info *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->connection_type = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1connection_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = (libtorrent::peer_info *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->connection_type);
  jresult = (jint)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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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_1deprecated_1estimated_1reciprocation_1rate_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::peer_info *arg1 = (libtorrent::peer_info *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->deprecated_estimated_reciprocation_rate = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1info_1deprecated_1estimated_1reciprocation_1rate_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::peer_info *arg1 = (libtorrent::peer_info *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_info **)&jarg1; 
  result = (int) ((arg1)->deprecated_estimated_reciprocation_rate);
  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 = (libtorrent::peer_info *) 0 ;
  libtorrent::tcp::endpoint *arg2 = (libtorrent::tcp::endpoint *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 0 ;
  libtorrent::tcp::endpoint *arg2 = (libtorrent::tcp::endpoint *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 0 ;
  libtorrent::bandwidth_state_flags_t *arg2 = (libtorrent::bandwidth_state_flags_t *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 0 ;
  libtorrent::bandwidth_state_flags_t *arg2 = (libtorrent::bandwidth_state_flags_t *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 >((const 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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 = (libtorrent::peer_info *) 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_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_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_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 = 0 ;
  libtorrent::web_seed_entry::type_t arg2 ;
  std::string *arg3 = 0 ;
  libtorrent::web_seed_entry::headers_t *arg4 = 0 ;
  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 = (const char *)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::web_seed_entry::type_t)jarg2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg3_pstr = (const char *)jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return 0;
  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 & reference is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::web_seed_entry *)new libtorrent::web_seed_entry((std::string const &)*arg1,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 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 = 0 ;
  libtorrent::web_seed_entry::type_t arg2 ;
  std::string *arg3 = 0 ;
  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 = (const char *)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::web_seed_entry::type_t)jarg2; 
  if(!jarg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return 0;
  }
  const char *arg3_pstr = (const char *)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::web_seed_entry *)new libtorrent::web_seed_entry((std::string const &)*arg1,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;
    }
  }
  *(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 = 0 ;
  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 = (const char *)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::web_seed_entry::type_t)jarg2; 
  {
    try {
      result = (libtorrent::web_seed_entry *)new libtorrent::web_seed_entry((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::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 = (libtorrent::web_seed_entry *) 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 & reference 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 = (libtorrent::web_seed_entry *) 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 & reference 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 = (libtorrent::web_seed_entry *) 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 = (const char *)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 = (libtorrent::web_seed_entry *) 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 = (libtorrent::web_seed_entry *) 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 = (const char *)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 = (libtorrent::web_seed_entry *) 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 = (libtorrent::web_seed_entry *) 0 ;
  libtorrent::web_seed_entry::headers_t *arg2 = (libtorrent::web_seed_entry::headers_t *) 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 = (libtorrent::web_seed_entry *) 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 = (libtorrent::web_seed_entry *) 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 = (libtorrent::web_seed_entry *) 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 = (libtorrent::web_seed_entry *) 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 = (libtorrent::load_torrent_limits *) 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 = (libtorrent::load_torrent_limits *) 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 = (libtorrent::load_torrent_limits *) 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 = (libtorrent::load_torrent_limits *) 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 = (libtorrent::load_torrent_limits *) 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 = (libtorrent::load_torrent_limits *) 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 = (libtorrent::load_torrent_limits *) 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 = (libtorrent::load_torrent_limits *) 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 = (libtorrent::load_torrent_limits *) 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 & reference 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::sha1_hash *arg1 = 0 ;
  libtorrent::torrent_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::sha1_hash **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & reference is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::torrent_info *)new libtorrent::torrent_info((libtorrent::sha1_hash 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 & reference is null");
    return 0;
  } 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & reference 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 = (const char *)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 & reference 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 = (const char *)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(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 = (libtorrent::torrent_info *) 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 & reference 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 = (libtorrent::torrent_info *) 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 = (const char *)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 = (libtorrent::torrent_info *) 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 = (const char *)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 = (libtorrent::torrent_info *) 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 = (const char *)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 = (libtorrent::torrent_info *) 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1similar_1torrents(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = (libtorrent::torrent_info *) 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 >((const 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 = (libtorrent::torrent_info *) 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 >((const 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 = (libtorrent::torrent_info *) 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 = (const char *)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 = (const char *)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 & reference 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 = (libtorrent::torrent_info *) 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 = (const char *)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 = (const char *)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 = (libtorrent::torrent_info *) 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 = (const char *)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 = (libtorrent::torrent_info *) 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 = (const char *)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 = (const char *)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 & reference 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 = (libtorrent::torrent_info *) 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 = (const char *)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 = (const char *)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 = (libtorrent::torrent_info *) 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 = (const char *)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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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(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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (libtorrent::sha1_hash *) &((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 = 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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(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 >((const 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 = (libtorrent::torrent_info *) 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(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((const libtorrent::peer_request &)result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1ssl_1cert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = (libtorrent::torrent_info *) 0 ;
  libtorrent::string_view result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = ((libtorrent::torrent_info const *)arg1)->ssl_cert();
    } catch (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 = new libtorrent::string_view((const libtorrent::string_view &)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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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(arg2);
    } catch (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 = (libtorrent::torrent_info *) 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(arg2);
    } catch (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((const 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 = (libtorrent::torrent_info *) 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1merkle_1tree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_info *arg1 = (libtorrent::torrent_info *) 0 ;
  std::vector< libtorrent::sha1_hash > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (std::vector< libtorrent::sha1_hash > *) &((libtorrent::torrent_info const *)arg1)->merkle_tree();
    } catch (std::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 = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1set_1merkle_1tree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_info *arg1 = (libtorrent::torrent_info *) 0 ;
  std::vector< libtorrent::sha1_hash > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  arg2 = *(std::vector< libtorrent::sha1_hash > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::sha1_hash > & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->set_merkle_tree(*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_torrent_1info_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::torrent_info *arg1 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 = (libtorrent::torrent_info *) 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 & reference 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 = (libtorrent::torrent_info *) 0 ;
  char *arg2 = (char *) 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((const libtorrent::bdecode_node &)result); 
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1metadata_1size(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::torrent_info *arg1 = (libtorrent::torrent_info *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::torrent_info const *)arg1)->metadata_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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1info_1is_1merkle_1torrent(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_info *arg1 = (libtorrent::torrent_info *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_info **)&jarg1; 
  {
    try {
      result = (bool)((libtorrent::torrent_info const *)arg1)->is_merkle_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;
    }
  }
  jresult = (jboolean)result; 
  return jresult;
}


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 ;
  int64_t arg1 ;
  int arg2 ;
  libtorrent::error_code *arg3 = 0 ;
  libtorrent::torrent_info *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg3_;
  arg1 = (int64_t)jarg1; 
  arg2 = (int)jarg2; 
  arg3 = *(libtorrent::error_code **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & reference 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_pex_1encryption_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::pex_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::pex_flags_t *)&libtorrent::pex_encryption;
  *(libtorrent::pex_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1seed_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::pex_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::pex_flags_t *)&libtorrent::pex_seed;
  *(libtorrent::pex_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1utp_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::pex_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::pex_flags_t *)&libtorrent::pex_utp;
  *(libtorrent::pex_flags_t **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_pex_1holepunch_1get(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::pex_flags_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::pex_flags_t *)&libtorrent::pex_holepunch;
  *(libtorrent::pex_flags_t **)&jresult = result; 
  return jresult;
}


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 = (libtorrent::torrent_status *) 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 & reference 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 = (libtorrent::torrent_status *) 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 & reference 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 = (libtorrent::torrent_status *) 0 ;
  libtorrent::torrent_handle *arg2 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_status *) 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_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 = (libtorrent::torrent_status *) 0 ;
  libtorrent::error_code *arg2 = (libtorrent::error_code *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (const char *)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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (const char *)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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (const char *)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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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_1pieces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_status *arg1 = (libtorrent::torrent_status *) 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg2 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg2; 
  if (arg1) (arg1)->pieces = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1pieces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = (libtorrent::torrent_status *) 0 ;
  libtorrent::typed_bitfield< piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (libtorrent::typed_bitfield< piece_index_t > *)& ((arg1)->pieces);
  *(libtorrent::typed_bitfield< piece_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1verified_1pieces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_status *arg1 = (libtorrent::torrent_status *) 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg2 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg2; 
  if (arg1) (arg1)->verified_pieces = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1verified_1pieces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = (libtorrent::torrent_status *) 0 ;
  libtorrent::typed_bitfield< piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  result = (libtorrent::typed_bitfield< piece_index_t > *)& ((arg1)->verified_pieces);
  *(libtorrent::typed_bitfield< piece_index_t > **)&jresult = 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_status *arg1 = (libtorrent::torrent_status *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_status **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->info_hash = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1status_1info_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_status *arg1 = (libtorrent::torrent_status *) 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_status **)&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_torrent_1status_1flags_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_status *arg1 = (libtorrent::torrent_status *) 0 ;
  libtorrent::torrent_flags_t *arg2 = (libtorrent::torrent_flags_t *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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 = (libtorrent::torrent_status *) 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_block_1info_1peer(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::block_info *arg1 = (libtorrent::block_info *) 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((const 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 = (libtorrent::block_info *) 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 = (libtorrent::block_info *) 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 = (libtorrent::block_info *) 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 = (libtorrent::block_info *) 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 = (libtorrent::block_info *) 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 = (libtorrent::block_info *) 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 = (libtorrent::block_info *) 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 = (libtorrent::block_info *) 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 = (libtorrent::block_info *) 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 = (libtorrent::partial_piece_info *) 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 = (libtorrent::partial_piece_info *) 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 = (libtorrent::partial_piece_info *) 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 = (libtorrent::partial_piece_info *) 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 = (libtorrent::partial_piece_info *) 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 = (libtorrent::partial_piece_info *) 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 = (libtorrent::partial_piece_info *) 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 = (libtorrent::partial_piece_info *) 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 = (libtorrent::partial_piece_info *) 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 = (libtorrent::partial_piece_info *) 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 = (libtorrent::partial_piece_info *) 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 = (libtorrent::torrent_handle *) 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(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 = (libtorrent::torrent_handle *) 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(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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_1get_1peer_1info(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 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 > & reference 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 = (libtorrent::torrent_handle *) 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(arg2);
    } catch (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((const 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 = (libtorrent::torrent_handle *) 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((const libtorrent::torrent_status &)result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1get_1download_1queue(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 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 > & reference 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 = (libtorrent::torrent_handle *) 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(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_torrent_1handle_1set_1piece_1deadline_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jint jarg3) {
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 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(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 = (libtorrent::torrent_handle *) 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(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 = (libtorrent::torrent_handle *) 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 jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1piece_1granularity_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::torrent_handle::file_progress_flags_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::torrent_handle::file_progress_flags_t)libtorrent::torrent_handle::piece_granularity;
  jresult = (jint)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_, jint jarg3) {
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 0 ;
  std::vector< std::int64_t > *arg2 = 0 ;
  int arg3 ;
  
  (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 > & reference is null");
    return ;
  } 
  arg3 = (int)jarg3; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->file_progress(*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_1file_1progress_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 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 > & reference 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 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 >((const 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 = (libtorrent::torrent_handle *) 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 & reference 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 = (libtorrent::torrent_handle *) 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 & reference 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_1add_1url_1seed(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 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 = (const char *)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 = (libtorrent::torrent_handle *) 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 = (const char *)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 = (libtorrent::torrent_handle *) 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 = (const char *)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 = (libtorrent::torrent_handle *) 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 = (const char *)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 = (libtorrent::torrent_handle *) 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1clear_1disk_1cache_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::clear_disk_cache;
  *(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 = (libtorrent::torrent_handle *) 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(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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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((const 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 = (libtorrent::torrent_handle *) 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(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_1set_1flags_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 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(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 = (libtorrent::torrent_handle *) 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(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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 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 = (libtorrent::torrent_handle *) 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(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 = (libtorrent::torrent_handle *) 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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1handle_1need_1save_1resume_1data(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 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 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (const char *)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 = (const char *)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 = (const char *)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 = (const char *)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 = (libtorrent::torrent_handle *) 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 = (const char *)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 = (const char *)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 = (const char *)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 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 = (libtorrent::torrent_handle *) 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 > & reference 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 = (libtorrent::torrent_handle *) 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,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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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_1scrape_1tracker_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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, jobject jarg4_) {
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 0 ;
  libtorrent::tcp::endpoint *arg2 = 0 ;
  libtorrent::peer_source_flags_t arg3 ;
  libtorrent::pex_flags_t arg4 ;
  libtorrent::peer_source_flags_t *argp3 ;
  libtorrent::pex_flags_t *argp4 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  (void)jarg4_;
  arg1 = *(libtorrent::torrent_handle **)&jarg1; 
  arg2 = *(libtorrent::tcp::endpoint **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::tcp::endpoint const & reference 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 = *(libtorrent::pex_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::pex_flags_t");
    return ;
  }
  arg4 = *argp4; 
  {
    try {
      ((libtorrent::torrent_handle const *)arg1)->connect_peer((libtorrent::tcp::endpoint 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_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 = (libtorrent::torrent_handle *) 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 & reference 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,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 = (libtorrent::torrent_handle *) 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 & reference 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (const char *)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 = (libtorrent::torrent_handle *) 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 = (const char *)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 = (libtorrent::torrent_handle *) 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 = (const char *)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(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 = (libtorrent::torrent_handle *) 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((const libtorrent::sha1_hash &)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 = (libtorrent::torrent_handle *) 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 & reference 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 = (libtorrent::torrent_handle *) 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 & reference 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 = (libtorrent::torrent_handle *) 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 & reference 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 = (libtorrent::torrent_handle *) 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 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 & reference 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,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 = (libtorrent::torrent_handle *) 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 & reference 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 = (libtorrent::torrent_handle *) 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_1get_1url_1seeds(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 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 >((const 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 = (libtorrent::torrent_handle *) 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 >((const 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 = (libtorrent::torrent_handle *) 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 & reference is null");
    return ;
  } 
  arg3 = *(std::vector< int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & reference is null");
    return ;
  } 
  arg4 = *(std::vector< int8_t > **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & reference 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_handle *) 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,arg2);
    } catch (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 = (libtorrent::torrent_handle *) 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,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 = (libtorrent::torrent_handle *) 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 & reference 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, jobject jarg2_) {
  libtorrent::torrent_handle *arg1 = (libtorrent::torrent_handle *) 0 ;
  std::vector< std::pair< piece_index_t,int > > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  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 & reference 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 = (libtorrent::torrent_handle *) 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 >((const 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 = (libtorrent::torrent_handle *) 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,arg2);
    } catch (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 = (libtorrent::torrent_handle *) 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,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 = (libtorrent::torrent_handle *) 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 & reference 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 = (libtorrent::torrent_handle *) 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 >((const 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 = (libtorrent::torrent_handle *) 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 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (const char *)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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (const char *)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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (const char *)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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 0 ;
  libtorrent::torrent_flags_t *arg2 = (libtorrent::torrent_flags_t *) 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 = (libtorrent::add_torrent_params *) 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_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->info_hash = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1info_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&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_add_1torrent_1params_1max_1uploads_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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_1have_1pieces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg2 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg2; 
  if (arg1) (arg1)->have_pieces = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1have_1pieces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 0 ;
  libtorrent::typed_bitfield< piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (libtorrent::typed_bitfield< piece_index_t > *)& ((arg1)->have_pieces);
  *(libtorrent::typed_bitfield< piece_index_t > **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1verified_1pieces_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 0 ;
  libtorrent::typed_bitfield< piece_index_t > *arg2 = (libtorrent::typed_bitfield< piece_index_t > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(libtorrent::typed_bitfield< piece_index_t > **)&jarg2; 
  if (arg1) (arg1)->verified_pieces = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1verified_1pieces_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 0 ;
  libtorrent::typed_bitfield< piece_index_t > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  result = (libtorrent::typed_bitfield< piece_index_t > *)& ((arg1)->verified_pieces);
  *(libtorrent::typed_bitfield< piece_index_t > **)&jresult = 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_params *) 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 & reference 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1renamed_1files(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 0 ;
  std::map< file_index_t,std::string > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::map< file_index_t,std::string > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::map< file_index_t,std::string > const & reference is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_renamed_files(arg1,(std::map< file_index_t,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_1tracker_1tiers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 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 >((const 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 = (libtorrent::add_torrent_params *) 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 & reference 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1merkle_1tree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 0 ;
  std::vector< libtorrent::sha1_hash > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  arg2 = *(std::vector< libtorrent::sha1_hash > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< libtorrent::sha1_hash > const & reference is null");
    return ;
  } 
  {
    try {
      libtorrent_add_torrent_params_set_merkle_tree(arg1,(std::vector< 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_add_1torrent_1params_1get_1banned_1peers(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 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 >((const 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 = (libtorrent::add_torrent_params *) 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 & reference 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 = (libtorrent::add_torrent_params *) 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 >((const 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 = (libtorrent::add_torrent_params *) 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 & reference 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 = (libtorrent::add_torrent_params *) 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 & reference 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 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 = (libtorrent::add_torrent_params *) 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 > >((const 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 = (libtorrent::add_torrent_params *) 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 & reference 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 = (libtorrent::add_torrent_params *) 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 & reference 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 = (libtorrent::add_torrent_params *) 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 >((const 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 = (libtorrent::add_torrent_params *) 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 & reference 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 = (libtorrent::add_torrent_params *) 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 >((const 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 = (libtorrent::add_torrent_params *) 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 & reference 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 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 = (libtorrent::add_torrent_params *) 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 & reference 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_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((const libtorrent::add_torrent_params &)result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1create_1instance_1disabled_1storage(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent_add_torrent_params_create_instance_disabled_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::add_torrent_params **)&jresult = new libtorrent::add_torrent_params((const libtorrent::add_torrent_params &)result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1create_1instance_1zero_1storage(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::add_torrent_params result;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = libtorrent_add_torrent_params_create_instance_zero_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::add_torrent_params **)&jresult = new libtorrent::add_torrent_params((const libtorrent::add_torrent_params &)result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_add_1torrent_1params_1set_1default_1storage(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      libtorrent_add_torrent_params_set_default_storage(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_1set_1disabled_1storage(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      libtorrent_add_torrent_params_set_disabled_storage(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_1set_1zero_1storage(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  libtorrent::add_torrent_params *arg1 = (libtorrent::add_torrent_params *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::add_torrent_params **)&jarg1; 
  {
    try {
      libtorrent_add_torrent_params_set_zero_storage(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_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 & reference is null");
    return 0;
  } 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & reference 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((const 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 & reference is null");
    return 0;
  } 
  arg2 = *(libtorrent::error_code **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & reference 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((const 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 & reference 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((const 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 & reference 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 >((const 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 = (const char *)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 & reference 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((const libtorrent::add_torrent_params &)result); 
  return jresult;
}


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 = (libtorrent::add_torrent_params *) 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 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 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 = (libtorrent::stats_metric *) 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 = (libtorrent::stats_metric *) 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 = (libtorrent::stats_metric *) 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 = (libtorrent::stats_metric *) 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 = (libtorrent::stats_metric *) 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 = (libtorrent::stats_metric *) 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 >((const std::vector< libtorrent::stats_metric > &)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_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_1stats_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::stats_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 = (libtorrent::alert *) 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 = (libtorrent::alert *) 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 = (libtorrent::alert *) 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 = (libtorrent::alert *) 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 = (libtorrent::alert *) 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((const libtorrent::alert_category_t &)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 = (libtorrent::alert *) 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_1read_1piece_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1file_1completed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1renamed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1file_1rename_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1performance_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1state_1changed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1tracker_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1warning_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1scrape_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1scrape_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1tracker_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1dht_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1tracker_1announce_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1hash_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1peer_1ban_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1unsnubbed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1peer_1snubbed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1connect_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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 = (libtorrent::alert *) 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_1invalid_1request_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1torrent_1finished_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1piece_1finished_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1request_1dropped_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1block_1timeout_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1finished_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1downloading_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1unwanted_1block_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1storage_1moved_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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 = (libtorrent::alert *) 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_1deleted_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1delete_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1save_1resume_1data_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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 = (libtorrent::alert *) 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_1torrent_1paused_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1resumed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1torrent_1checked_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1url_1seed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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 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 = (libtorrent::alert *) 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_1metadata_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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 = (libtorrent::alert *) 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_1udp_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1external_1ip_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1listen_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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 = (libtorrent::alert *) 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_1portmap_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1fastresume_1rejected_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1peer_1blocked_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1dht_1announce_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1get_1peers_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1stats_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 0 ;
  libtorrent::stats_alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alert **)&jarg1; 
  {
    try {
      result = (libtorrent::stats_alert *)libtorrent_alert_cast_to_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::stats_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 = (libtorrent::alert *) 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_1lsd_1peer_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1trackerid_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1dht_1bootstrap_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1torrent_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1need_1cert_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1incoming_1connection_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1add_1torrent_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1state_1update_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1session_1stats_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1dht_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1immutable_1item_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1mutable_1item_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1put_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1i2p_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1dht_1outgoing_1get_1peers_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1torrent_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1peer_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1lsd_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1dht_1stats_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1incoming_1request_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1dht_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1pkt_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1get_1peers_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1direct_1response_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1picker_1log_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1session_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1dht_1live_1nodes_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1session_1stats_1header_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1dht_1sample_1infohashes_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1block_1uploaded_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1alerts_1dropped_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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_1get_1timestamp(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::alert *arg1 = (libtorrent::alert *) 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 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_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 = (libtorrent::dht_routing_bucket *) 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 = (libtorrent::dht_routing_bucket *) 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 = (libtorrent::dht_routing_bucket *) 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 = (libtorrent::dht_routing_bucket *) 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 = (libtorrent::dht_routing_bucket *) 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 = (libtorrent::dht_routing_bucket *) 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 = (libtorrent::dht_routing_bucket *) 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 = (libtorrent::torrent_alert *) 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 = (libtorrent::torrent_alert *) 0 ;
  libtorrent::torrent_handle *arg2 = (libtorrent::torrent_handle *) 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 = (libtorrent::torrent_alert *) 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 = (libtorrent::torrent_alert *) 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 = (libtorrent::torrent_alert *) 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 = (libtorrent::peer_alert *) 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 = (libtorrent::peer_alert *) 0 ;
  libtorrent::peer_id *arg2 = (libtorrent::peer_id *) 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 = (libtorrent::peer_alert *) 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 = (libtorrent::peer_alert *) 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((const 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 = (libtorrent::peer_alert *) 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 = (libtorrent::tracker_alert *) 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 = (libtorrent::tracker_alert *) 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 = (libtorrent::tracker_alert *) 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((const 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 = (libtorrent::tracker_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::torrent_removed_alert *) 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 = (libtorrent::torrent_removed_alert *) 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((const 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 = (libtorrent::torrent_removed_alert *) 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 = (libtorrent::torrent_removed_alert *) 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_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_removed_alert *arg1 = (libtorrent::torrent_removed_alert *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_removed_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->info_hash = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1removed_1alert_1info_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_removed_alert *arg1 = (libtorrent::torrent_removed_alert *) 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_removed_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_1torrent_1removed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_removed_alert *arg1 = (libtorrent::torrent_removed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::read_piece_alert *) 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 = (libtorrent::read_piece_alert *) 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((const 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 = (libtorrent::read_piece_alert *) 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 = (libtorrent::read_piece_alert *) 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 = (libtorrent::read_piece_alert *) 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 = (libtorrent::read_piece_alert *) 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 = (libtorrent::read_piece_alert *) 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 = (libtorrent::read_piece_alert *) 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 = (libtorrent::read_piece_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::file_completed_alert *) 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 = (libtorrent::file_completed_alert *) 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((const 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 = (libtorrent::file_completed_alert *) 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 = (libtorrent::file_completed_alert *) 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 = (libtorrent::file_completed_alert *) 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 = (libtorrent::file_completed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::file_renamed_alert *) 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 = (libtorrent::file_renamed_alert *) 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((const 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 = (libtorrent::file_renamed_alert *) 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 = (libtorrent::file_renamed_alert *) 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 = (libtorrent::file_renamed_alert *) 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 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 = (libtorrent::file_renamed_alert *) 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 = (libtorrent::file_renamed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::file_rename_failed_alert *) 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 = (libtorrent::file_rename_failed_alert *) 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((const 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 = (libtorrent::file_rename_failed_alert *) 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 = (libtorrent::file_rename_failed_alert *) 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 = (libtorrent::file_rename_failed_alert *) 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 = (libtorrent::file_rename_failed_alert *) 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 = (libtorrent::file_rename_failed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::performance_alert *) 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 = (libtorrent::performance_alert *) 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((const 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 = (libtorrent::performance_alert *) 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 = (libtorrent::performance_alert *) 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 = (libtorrent::performance_alert *) 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 = (libtorrent::performance_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::state_changed_alert *) 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 = (libtorrent::state_changed_alert *) 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((const 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 = (libtorrent::state_changed_alert *) 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 = (libtorrent::state_changed_alert *) 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 = (libtorrent::state_changed_alert *) 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 = (libtorrent::state_changed_alert *) 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 = (libtorrent::state_changed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::tracker_error_alert *) 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 = (libtorrent::tracker_error_alert *) 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((const 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 = (libtorrent::tracker_error_alert *) 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 = (libtorrent::tracker_error_alert *) 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 = (libtorrent::tracker_error_alert *) 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 = (libtorrent::tracker_error_alert *) 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 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 = (libtorrent::tracker_error_alert *) 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_delete_1tracker_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::tracker_error_alert *arg1 = (libtorrent::tracker_error_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::tracker_warning_alert *) 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 = (libtorrent::tracker_warning_alert *) 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((const 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 = (libtorrent::tracker_warning_alert *) 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 = (libtorrent::tracker_warning_alert *) 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 = (libtorrent::tracker_warning_alert *) 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_delete_1tracker_1warning_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::tracker_warning_alert *arg1 = (libtorrent::tracker_warning_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::scrape_reply_alert *) 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 = (libtorrent::scrape_reply_alert *) 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((const 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 = (libtorrent::scrape_reply_alert *) 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 = (libtorrent::scrape_reply_alert *) 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 = (libtorrent::scrape_reply_alert *) 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 = (libtorrent::scrape_reply_alert *) 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_delete_1scrape_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::scrape_reply_alert *arg1 = (libtorrent::scrape_reply_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::scrape_failed_alert *) 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 = (libtorrent::scrape_failed_alert *) 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((const 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 = (libtorrent::scrape_failed_alert *) 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 = (libtorrent::scrape_failed_alert *) 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 = (libtorrent::scrape_failed_alert *) 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 = (libtorrent::scrape_failed_alert *) 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_delete_1scrape_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::scrape_failed_alert *arg1 = (libtorrent::scrape_failed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::tracker_reply_alert *) 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 = (libtorrent::tracker_reply_alert *) 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((const 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 = (libtorrent::tracker_reply_alert *) 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 = (libtorrent::tracker_reply_alert *) 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 = (libtorrent::tracker_reply_alert *) 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_delete_1tracker_1reply_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::tracker_reply_alert *arg1 = (libtorrent::tracker_reply_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_reply_alert *) 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 = (libtorrent::dht_reply_alert *) 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((const 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 = (libtorrent::dht_reply_alert *) 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 = (libtorrent::dht_reply_alert *) 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 = (libtorrent::dht_reply_alert *) 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 = (libtorrent::dht_reply_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::tracker_announce_alert *) 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 = (libtorrent::tracker_announce_alert *) 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((const 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 = (libtorrent::tracker_announce_alert *) 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 = (libtorrent::tracker_announce_alert *) 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 = (libtorrent::tracker_announce_alert *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::tracker_announce_alert **)&jarg1; 
  result = (int)(int) ((arg1)->event);
  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 = (libtorrent::tracker_announce_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::hash_failed_alert *) 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 = (libtorrent::hash_failed_alert *) 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((const 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 = (libtorrent::hash_failed_alert *) 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 = (libtorrent::hash_failed_alert *) 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 = (libtorrent::hash_failed_alert *) 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 = (libtorrent::hash_failed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::peer_ban_alert *) 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 = (libtorrent::peer_ban_alert *) 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((const 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 = (libtorrent::peer_ban_alert *) 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 = (libtorrent::peer_ban_alert *) 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 = (libtorrent::peer_ban_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::peer_unsnubbed_alert *) 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 = (libtorrent::peer_unsnubbed_alert *) 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((const 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 = (libtorrent::peer_unsnubbed_alert *) 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 = (libtorrent::peer_unsnubbed_alert *) 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 = (libtorrent::peer_unsnubbed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::peer_snubbed_alert *) 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 = (libtorrent::peer_snubbed_alert *) 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((const 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 = (libtorrent::peer_snubbed_alert *) 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 = (libtorrent::peer_snubbed_alert *) 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 = (libtorrent::peer_snubbed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::peer_error_alert *) 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 = (libtorrent::peer_error_alert *) 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((const 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 = (libtorrent::peer_error_alert *) 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 = (libtorrent::peer_error_alert *) 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 = (libtorrent::peer_error_alert *) 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 = (libtorrent::peer_error_alert *) 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 = (libtorrent::peer_error_alert *) 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 = (libtorrent::peer_error_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::peer_connect_alert *) 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 = (libtorrent::peer_connect_alert *) 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((const 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 = (libtorrent::peer_connect_alert *) 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 = (libtorrent::peer_connect_alert *) 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 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 = (libtorrent::peer_connect_alert *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_connect_alert **)&jarg1; 
  result = (int)(int) ((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 = (libtorrent::peer_connect_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::peer_disconnected_alert *) 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 = (libtorrent::peer_disconnected_alert *) 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((const 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 = (libtorrent::peer_disconnected_alert *) 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 = (libtorrent::peer_disconnected_alert *) 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 = (libtorrent::peer_disconnected_alert *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_disconnected_alert **)&jarg1; 
  result = (int)(int) ((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 = (libtorrent::peer_disconnected_alert *) 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 = (libtorrent::peer_disconnected_alert *) 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 = (libtorrent::peer_disconnected_alert *) 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 = (libtorrent::peer_disconnected_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::invalid_request_alert *) 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 = (libtorrent::invalid_request_alert *) 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((const 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 = (libtorrent::invalid_request_alert *) 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 = (libtorrent::invalid_request_alert *) 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 = (libtorrent::invalid_request_alert *) 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 = (libtorrent::invalid_request_alert *) 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 = (libtorrent::invalid_request_alert *) 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 = (libtorrent::invalid_request_alert *) 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 = (libtorrent::invalid_request_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::torrent_finished_alert *) 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 = (libtorrent::torrent_finished_alert *) 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((const 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 = (libtorrent::torrent_finished_alert *) 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 = (libtorrent::torrent_finished_alert *) 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 = (libtorrent::torrent_finished_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::piece_finished_alert *) 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 = (libtorrent::piece_finished_alert *) 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((const 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 = (libtorrent::piece_finished_alert *) 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 = (libtorrent::piece_finished_alert *) 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 = (libtorrent::piece_finished_alert *) 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 = (libtorrent::piece_finished_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::request_dropped_alert *) 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 = (libtorrent::request_dropped_alert *) 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((const 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 = (libtorrent::request_dropped_alert *) 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 = (libtorrent::request_dropped_alert *) 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 = (libtorrent::request_dropped_alert *) 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 = (libtorrent::request_dropped_alert *) 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 = (libtorrent::request_dropped_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::block_timeout_alert *) 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 = (libtorrent::block_timeout_alert *) 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((const 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 = (libtorrent::block_timeout_alert *) 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 = (libtorrent::block_timeout_alert *) 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 = (libtorrent::block_timeout_alert *) 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 = (libtorrent::block_timeout_alert *) 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 = (libtorrent::block_timeout_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::block_finished_alert *) 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 = (libtorrent::block_finished_alert *) 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((const 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 = (libtorrent::block_finished_alert *) 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 = (libtorrent::block_finished_alert *) 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 = (libtorrent::block_finished_alert *) 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 = (libtorrent::block_finished_alert *) 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 = (libtorrent::block_finished_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::block_downloading_alert *) 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 = (libtorrent::block_downloading_alert *) 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((const 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 = (libtorrent::block_downloading_alert *) 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 = (libtorrent::block_downloading_alert *) 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 = (libtorrent::block_downloading_alert *) 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 = (libtorrent::block_downloading_alert *) 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 = (libtorrent::block_downloading_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::unwanted_block_alert *) 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 = (libtorrent::unwanted_block_alert *) 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((const 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 = (libtorrent::unwanted_block_alert *) 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 = (libtorrent::unwanted_block_alert *) 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 = (libtorrent::unwanted_block_alert *) 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 = (libtorrent::unwanted_block_alert *) 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 = (libtorrent::unwanted_block_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::storage_moved_alert *) 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 = (libtorrent::storage_moved_alert *) 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((const 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 = (libtorrent::storage_moved_alert *) 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 = (libtorrent::storage_moved_alert *) 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 = (libtorrent::storage_moved_alert *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1storage_1moved_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::storage_moved_alert *arg1 = (libtorrent::storage_moved_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::storage_moved_failed_alert *) 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 = (libtorrent::storage_moved_failed_alert *) 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((const 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 = (libtorrent::storage_moved_failed_alert *) 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 = (libtorrent::storage_moved_failed_alert *) 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 = (libtorrent::storage_moved_failed_alert *) 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 = (libtorrent::storage_moved_failed_alert *) 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 = (libtorrent::storage_moved_failed_alert *) 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 = (libtorrent::storage_moved_failed_alert *) 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 = (libtorrent::storage_moved_failed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::torrent_deleted_alert *) 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 = (libtorrent::torrent_deleted_alert *) 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((const 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 = (libtorrent::torrent_deleted_alert *) 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 = (libtorrent::torrent_deleted_alert *) 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_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_deleted_alert *arg1 = (libtorrent::torrent_deleted_alert *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_deleted_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->info_hash = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1deleted_1alert_1info_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_deleted_alert *arg1 = (libtorrent::torrent_deleted_alert *) 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_deleted_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_1torrent_1deleted_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_deleted_alert *arg1 = (libtorrent::torrent_deleted_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::torrent_delete_failed_alert *) 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 = (libtorrent::torrent_delete_failed_alert *) 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((const 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 = (libtorrent::torrent_delete_failed_alert *) 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 = (libtorrent::torrent_delete_failed_alert *) 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 = (libtorrent::torrent_delete_failed_alert *) 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_1hash_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::torrent_delete_failed_alert *arg1 = (libtorrent::torrent_delete_failed_alert *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::torrent_delete_failed_alert **)&jarg1; 
  arg2 = *(libtorrent::sha1_hash **)&jarg2; 
  if (arg1) (arg1)->info_hash = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_torrent_1delete_1failed_1alert_1info_1hash_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::torrent_delete_failed_alert *arg1 = (libtorrent::torrent_delete_failed_alert *) 0 ;
  libtorrent::sha1_hash *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::torrent_delete_failed_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_1torrent_1delete_1failed_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::torrent_delete_failed_alert *arg1 = (libtorrent::torrent_delete_failed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::save_resume_data_alert *) 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 = (libtorrent::save_resume_data_alert *) 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((const 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 = (libtorrent::save_resume_data_alert *) 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 = (libtorrent::save_resume_data_alert *) 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 = (libtorrent::save_resume_data_alert *) 0 ;
  libtorrent::add_torrent_params *arg2 = (libtorrent::add_torrent_params *) 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 = (libtorrent::save_resume_data_alert *) 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 = (libtorrent::save_resume_data_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::save_resume_data_failed_alert *) 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 = (libtorrent::save_resume_data_failed_alert *) 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((const 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 = (libtorrent::save_resume_data_failed_alert *) 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 = (libtorrent::save_resume_data_failed_alert *) 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 = (libtorrent::save_resume_data_failed_alert *) 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 = (libtorrent::save_resume_data_failed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::torrent_paused_alert *) 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 = (libtorrent::torrent_paused_alert *) 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((const 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 = (libtorrent::torrent_paused_alert *) 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 = (libtorrent::torrent_paused_alert *) 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 = (libtorrent::torrent_paused_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::torrent_resumed_alert *) 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 = (libtorrent::torrent_resumed_alert *) 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((const 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 = (libtorrent::torrent_resumed_alert *) 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 = (libtorrent::torrent_resumed_alert *) 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 = (libtorrent::torrent_resumed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::torrent_checked_alert *) 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 = (libtorrent::torrent_checked_alert *) 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((const 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 = (libtorrent::torrent_checked_alert *) 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 = (libtorrent::torrent_checked_alert *) 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 = (libtorrent::torrent_checked_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::url_seed_alert *) 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 = (libtorrent::url_seed_alert *) 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((const 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 = (libtorrent::url_seed_alert *) 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 = (libtorrent::url_seed_alert *) 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 = (libtorrent::url_seed_alert *) 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 = (libtorrent::url_seed_alert *) 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 = (libtorrent::url_seed_alert *) 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 = (libtorrent::url_seed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::file_error_alert *) 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 = (libtorrent::file_error_alert *) 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((const 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 = (libtorrent::file_error_alert *) 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 = (libtorrent::file_error_alert *) 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 = (libtorrent::file_error_alert *) 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 = (libtorrent::file_error_alert *) 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 = (libtorrent::file_error_alert *) 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 = (libtorrent::file_error_alert *) 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 = (libtorrent::file_error_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::metadata_failed_alert *) 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 = (libtorrent::metadata_failed_alert *) 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((const 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 = (libtorrent::metadata_failed_alert *) 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 = (libtorrent::metadata_failed_alert *) 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 = (libtorrent::metadata_failed_alert *) 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 = (libtorrent::metadata_failed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::metadata_received_alert *) 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 = (libtorrent::metadata_received_alert *) 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((const 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 = (libtorrent::metadata_received_alert *) 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 = (libtorrent::metadata_received_alert *) 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 = (libtorrent::metadata_received_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::udp_error_alert *) 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 = (libtorrent::udp_error_alert *) 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((const 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 = (libtorrent::udp_error_alert *) 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 = (libtorrent::udp_error_alert *) 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 = (libtorrent::udp_error_alert *) 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 = (libtorrent::udp_error_alert *) 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 = (libtorrent::udp_error_alert *) 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 = (libtorrent::udp_error_alert *) 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((const 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 = (libtorrent::udp_error_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::external_ip_alert *) 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 = (libtorrent::external_ip_alert *) 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((const 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 = (libtorrent::external_ip_alert *) 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 = (libtorrent::external_ip_alert *) 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 = (libtorrent::external_ip_alert *) 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((const 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 = (libtorrent::external_ip_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::listen_failed_alert *) 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 = (libtorrent::listen_failed_alert *) 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((const 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 = (libtorrent::listen_failed_alert *) 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 = (libtorrent::listen_failed_alert *) 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 = (libtorrent::listen_failed_alert *) 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 = (libtorrent::listen_failed_alert *) 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 = (libtorrent::listen_failed_alert *) 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 = (libtorrent::listen_failed_alert *) 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_1socket_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = (libtorrent::listen_failed_alert *) 0 ;
  libtorrent::socket_type_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_failed_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_listen_1failed_1alert_1port_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::listen_failed_alert *arg1 = (libtorrent::listen_failed_alert *) 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 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 = (libtorrent::listen_failed_alert *) 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((const 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 = (libtorrent::listen_failed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::listen_succeeded_alert *) 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 = (libtorrent::listen_succeeded_alert *) 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((const 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 = (libtorrent::listen_succeeded_alert *) 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 = (libtorrent::listen_succeeded_alert *) 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 = (libtorrent::listen_succeeded_alert *) 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 jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_listen_1succeeded_1alert_1socket_1type_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::listen_succeeded_alert *arg1 = (libtorrent::listen_succeeded_alert *) 0 ;
  libtorrent::socket_type_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::listen_succeeded_alert **)&jarg1; 
  result = (libtorrent::socket_type_t)(libtorrent::socket_type_t) ((arg1)->socket_type);
  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 = (libtorrent::listen_succeeded_alert *) 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((const libtorrent::address &)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 = (libtorrent::listen_succeeded_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::portmap_error_alert *) 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 = (libtorrent::portmap_error_alert *) 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((const 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 = (libtorrent::portmap_error_alert *) 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 = (libtorrent::portmap_error_alert *) 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 int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1error_1alert_1mapping_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::portmap_error_alert *arg1 = (libtorrent::portmap_error_alert *) 0 ;
  port_mapping_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_error_alert **)&jarg1; 
  result = (port_mapping_t) ((arg1)->mapping);
  {
    jresult = static_cast<int>(static_cast<int>(result));
  }
  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 = (libtorrent::portmap_error_alert *) 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 = (libtorrent::portmap_error_alert *) 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 = (libtorrent::portmap_error_alert *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1portmap_1error_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::portmap_error_alert *arg1 = (libtorrent::portmap_error_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::portmap_alert *) 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 = (libtorrent::portmap_alert *) 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((const 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 = (libtorrent::portmap_alert *) 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 = (libtorrent::portmap_alert *) 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 int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_portmap_1alert_1mapping_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  int jresult = 0 ;
  libtorrent::portmap_alert *arg1 = (libtorrent::portmap_alert *) 0 ;
  port_mapping_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::portmap_alert **)&jarg1; 
  result = (port_mapping_t) ((arg1)->mapping);
  {
    jresult = static_cast<int>(static_cast<int>(result));
  }
  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 = (libtorrent::portmap_alert *) 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 = (libtorrent::portmap_alert *) 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 = (libtorrent::portmap_alert *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1portmap_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::portmap_alert *arg1 = (libtorrent::portmap_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::portmap_log_alert *) 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 = (libtorrent::portmap_log_alert *) 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((const 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 = (libtorrent::portmap_log_alert *) 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 = (libtorrent::portmap_log_alert *) 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 = (libtorrent::portmap_log_alert *) 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 = (libtorrent::portmap_log_alert *) 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 = (libtorrent::portmap_log_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::fastresume_rejected_alert *) 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 = (libtorrent::fastresume_rejected_alert *) 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((const 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 = (libtorrent::fastresume_rejected_alert *) 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 = (libtorrent::fastresume_rejected_alert *) 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 = (libtorrent::fastresume_rejected_alert *) 0 ;
  libtorrent::error_code *arg2 = (libtorrent::error_code *) 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 = (libtorrent::fastresume_rejected_alert *) 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 = (libtorrent::fastresume_rejected_alert *) 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 = (libtorrent::fastresume_rejected_alert *) 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 = (libtorrent::fastresume_rejected_alert *) 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 = (libtorrent::fastresume_rejected_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::peer_blocked_alert *) 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 = (libtorrent::peer_blocked_alert *) 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((const 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 = (libtorrent::peer_blocked_alert *) 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 = (libtorrent::peer_blocked_alert *) 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 = (libtorrent::peer_blocked_alert *) 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 = (libtorrent::peer_blocked_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_announce_alert *) 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 = (libtorrent::dht_announce_alert *) 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((const 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 = (libtorrent::dht_announce_alert *) 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 = (libtorrent::dht_announce_alert *) 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 = (libtorrent::dht_announce_alert *) 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 = (libtorrent::dht_announce_alert *) 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 = (libtorrent::dht_announce_alert *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 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 = (libtorrent::dht_announce_alert *) 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 = (libtorrent::dht_announce_alert *) 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((const 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 = (libtorrent::dht_announce_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_get_peers_alert *) 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 = (libtorrent::dht_get_peers_alert *) 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((const 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 = (libtorrent::dht_get_peers_alert *) 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 = (libtorrent::dht_get_peers_alert *) 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 = (libtorrent::dht_get_peers_alert *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 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 = (libtorrent::dht_get_peers_alert *) 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 = (libtorrent::dht_get_peers_alert *) 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_stats_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::stats_alert::priority;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1alert_1alert_1type_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::stats_alert::alert_type;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1alert_1type(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::stats_alert *arg1 = (libtorrent::stats_alert *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::stats_alert **)&jarg1; 
  {
    try {
      result = (int)((libtorrent::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_stats_1alert_1category(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::stats_alert *arg1 = (libtorrent::stats_alert *) 0 ;
  libtorrent::alert_category_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::stats_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::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((const libtorrent::alert_category_t &)result); 
  return jresult;
}


SWIGEXPORT jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1alert_1what(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::stats_alert *arg1 = (libtorrent::stats_alert *) 0 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::stats_alert **)&jarg1; 
  {
    try {
      result = (char *)((libtorrent::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_stats_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::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_stats_1alert_1message(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jstring jresult = 0 ;
  libtorrent::stats_alert *arg1 = (libtorrent::stats_alert *) 0 ;
  std::string result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::stats_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::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 jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1alert_1download_1ip_1protocol_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::stats_alert::stats_channel result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::stats_alert::stats_channel)libtorrent::stats_alert::download_ip_protocol;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1alert_1num_1channels_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::stats_alert::stats_channel result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::stats_alert::stats_channel)libtorrent::stats_alert::num_channels;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1alert_1interval_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::stats_alert *arg1 = (libtorrent::stats_alert *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::stats_alert **)&jarg1; 
  result = (int)(int) ((arg1)->interval);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_stats_1alert_1get_1transferred(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  jint jresult = 0 ;
  libtorrent::stats_alert *arg1 = (libtorrent::stats_alert *) 0 ;
  int arg2 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::stats_alert **)&jarg1; 
  arg2 = (int)jarg2; 
  {
    try {
      result = (int)libtorrent_stats_alert_get_transferred(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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1stats_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::stats_alert *arg1 = (libtorrent::stats_alert *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::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_cache_1flushed_1alert_1priority_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::cache_flushed_alert *) 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 = (libtorrent::cache_flushed_alert *) 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((const 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 = (libtorrent::cache_flushed_alert *) 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 = (libtorrent::cache_flushed_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::lsd_peer_alert *) 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 = (libtorrent::lsd_peer_alert *) 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((const 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 = (libtorrent::lsd_peer_alert *) 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 = (libtorrent::lsd_peer_alert *) 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 = (libtorrent::lsd_peer_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::trackerid_alert *) 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 = (libtorrent::trackerid_alert *) 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((const 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 = (libtorrent::trackerid_alert *) 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 = (libtorrent::trackerid_alert *) 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 = (libtorrent::trackerid_alert *) 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 = (libtorrent::trackerid_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_bootstrap_alert *) 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 = (libtorrent::dht_bootstrap_alert *) 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((const 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 = (libtorrent::dht_bootstrap_alert *) 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 = (libtorrent::dht_bootstrap_alert *) 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 = (libtorrent::dht_bootstrap_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::torrent_error_alert *) 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 = (libtorrent::torrent_error_alert *) 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((const 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 = (libtorrent::torrent_error_alert *) 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 = (libtorrent::torrent_error_alert *) 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 = (libtorrent::torrent_error_alert *) 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 = (libtorrent::torrent_error_alert *) 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 = (libtorrent::torrent_error_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::torrent_need_cert_alert *) 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 = (libtorrent::torrent_need_cert_alert *) 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((const 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 = (libtorrent::torrent_need_cert_alert *) 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 = (libtorrent::torrent_need_cert_alert *) 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 = (libtorrent::torrent_need_cert_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::incoming_connection_alert *) 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 = (libtorrent::incoming_connection_alert *) 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((const 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 = (libtorrent::incoming_connection_alert *) 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 = (libtorrent::incoming_connection_alert *) 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 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 = (libtorrent::incoming_connection_alert *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::incoming_connection_alert **)&jarg1; 
  result = (int)(int) ((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 = (libtorrent::incoming_connection_alert *) 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((const 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 = (libtorrent::incoming_connection_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::add_torrent_alert *) 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 = (libtorrent::add_torrent_alert *) 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((const 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 = (libtorrent::add_torrent_alert *) 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 = (libtorrent::add_torrent_alert *) 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 = (libtorrent::add_torrent_alert *) 0 ;
  libtorrent::add_torrent_params *arg2 = (libtorrent::add_torrent_params *) 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 = (libtorrent::add_torrent_alert *) 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 = (libtorrent::add_torrent_alert *) 0 ;
  libtorrent::error_code *arg2 = (libtorrent::error_code *) 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 = (libtorrent::add_torrent_alert *) 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 = (libtorrent::add_torrent_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::state_update_alert *) 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 = (libtorrent::state_update_alert *) 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((const 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 = (libtorrent::state_update_alert *) 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 = (libtorrent::state_update_alert *) 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 = (libtorrent::state_update_alert *) 0 ;
  std::vector< libtorrent::torrent_status > *arg2 = (std::vector< libtorrent::torrent_status > *) 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 = (libtorrent::state_update_alert *) 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 = (libtorrent::state_update_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::session_stats_alert *) 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 = (libtorrent::session_stats_alert *) 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((const 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 = (libtorrent::session_stats_alert *) 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 = (libtorrent::session_stats_alert *) 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 = (libtorrent::session_stats_alert *) 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 = (libtorrent::session_stats_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_error_alert *) 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 = (libtorrent::dht_error_alert *) 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((const 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 = (libtorrent::dht_error_alert *) 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 = (libtorrent::dht_error_alert *) 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 = (libtorrent::dht_error_alert *) 0 ;
  libtorrent::error_code *arg2 = (libtorrent::error_code *) 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 = (libtorrent::dht_error_alert *) 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 = (libtorrent::dht_error_alert *) 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 = (libtorrent::dht_error_alert *) 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 = (libtorrent::dht_error_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_immutable_item_alert *) 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 = (libtorrent::dht_immutable_item_alert *) 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((const 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 = (libtorrent::dht_immutable_item_alert *) 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 = (libtorrent::dht_immutable_item_alert *) 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 = (libtorrent::dht_immutable_item_alert *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 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 = (libtorrent::dht_immutable_item_alert *) 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 = (libtorrent::dht_immutable_item_alert *) 0 ;
  libtorrent::entry *arg2 = (libtorrent::entry *) 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 = (libtorrent::dht_immutable_item_alert *) 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 = (libtorrent::dht_immutable_item_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_mutable_item_alert *) 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 = (libtorrent::dht_mutable_item_alert *) 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((const 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 = (libtorrent::dht_mutable_item_alert *) 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 = (libtorrent::dht_mutable_item_alert *) 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 = (libtorrent::dht_mutable_item_alert *) 0 ;
  libtorrent::entry *arg2 = (libtorrent::entry *) 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 = (libtorrent::dht_mutable_item_alert *) 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 = (libtorrent::dht_mutable_item_alert *) 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 = (libtorrent::dht_mutable_item_alert *) 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 = (libtorrent::dht_mutable_item_alert *) 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 >((const 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 = (libtorrent::dht_mutable_item_alert *) 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 >((const 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 = (libtorrent::dht_mutable_item_alert *) 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 = (libtorrent::dht_mutable_item_alert *) 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 >((const 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 = (libtorrent::dht_mutable_item_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_put_alert *) 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 = (libtorrent::dht_put_alert *) 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((const 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 = (libtorrent::dht_put_alert *) 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 = (libtorrent::dht_put_alert *) 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 = (libtorrent::dht_put_alert *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 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 = (libtorrent::dht_put_alert *) 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 = (libtorrent::dht_put_alert *) 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 = (libtorrent::dht_put_alert *) 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 = (libtorrent::dht_put_alert *) 0 ;
  std::vector< int8_t > 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::vector< int8_t > **)&jresult = new std::vector< int8_t >((const std::vector< int8_t > &)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 = (libtorrent::dht_put_alert *) 0 ;
  std::vector< int8_t > 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::vector< int8_t > **)&jresult = new std::vector< int8_t >((const std::vector< int8_t > &)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 = (libtorrent::dht_put_alert *) 0 ;
  std::vector< 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< int8_t > **)&jresult = new std::vector< int8_t >((const std::vector< 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 = (libtorrent::dht_put_alert *) 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 = (libtorrent::dht_put_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::i2p_alert *) 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 = (libtorrent::i2p_alert *) 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((const 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 = (libtorrent::i2p_alert *) 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 = (libtorrent::i2p_alert *) 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 = (libtorrent::i2p_alert *) 0 ;
  libtorrent::error_code *arg2 = (libtorrent::error_code *) 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 = (libtorrent::i2p_alert *) 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 = (libtorrent::i2p_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_outgoing_get_peers_alert *) 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 = (libtorrent::dht_outgoing_get_peers_alert *) 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((const 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 = (libtorrent::dht_outgoing_get_peers_alert *) 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 = (libtorrent::dht_outgoing_get_peers_alert *) 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 = (libtorrent::dht_outgoing_get_peers_alert *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 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 = (libtorrent::dht_outgoing_get_peers_alert *) 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 = (libtorrent::dht_outgoing_get_peers_alert *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 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 = (libtorrent::dht_outgoing_get_peers_alert *) 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 = (libtorrent::dht_outgoing_get_peers_alert *) 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((const 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 = (libtorrent::dht_outgoing_get_peers_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::log_alert *) 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 = (libtorrent::log_alert *) 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((const 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 = (libtorrent::log_alert *) 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 = (libtorrent::log_alert *) 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 = (libtorrent::log_alert *) 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 = (libtorrent::log_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::torrent_log_alert *) 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 = (libtorrent::torrent_log_alert *) 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((const 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 = (libtorrent::torrent_log_alert *) 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 = (libtorrent::torrent_log_alert *) 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 = (libtorrent::torrent_log_alert *) 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 = (libtorrent::torrent_log_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::peer_log_alert *) 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 = (libtorrent::peer_log_alert *) 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((const 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 = (libtorrent::peer_log_alert *) 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 = (libtorrent::peer_log_alert *) 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 = (libtorrent::peer_log_alert *) 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 = (libtorrent::peer_log_alert *) 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 = (libtorrent::peer_log_alert *) 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 = (libtorrent::peer_log_alert *) 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 = (libtorrent::peer_log_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::lsd_error_alert *) 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 = (libtorrent::lsd_error_alert *) 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((const 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 = (libtorrent::lsd_error_alert *) 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 = (libtorrent::lsd_error_alert *) 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 = (libtorrent::lsd_error_alert *) 0 ;
  libtorrent::error_code *arg2 = (libtorrent::error_code *) 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 = (libtorrent::lsd_error_alert *) 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 = (libtorrent::lsd_error_alert *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 = (libtorrent::dht_lookup *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_stats_alert *) 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 = (libtorrent::dht_stats_alert *) 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((const 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 = (libtorrent::dht_stats_alert *) 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 = (libtorrent::dht_stats_alert *) 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 = (libtorrent::dht_stats_alert *) 0 ;
  std::vector< libtorrent::dht_lookup > *arg2 = (std::vector< libtorrent::dht_lookup > *) 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 = (libtorrent::dht_stats_alert *) 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 = (libtorrent::dht_stats_alert *) 0 ;
  std::vector< libtorrent::dht_routing_bucket > *arg2 = (std::vector< libtorrent::dht_routing_bucket > *) 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 = (libtorrent::dht_stats_alert *) 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_delete_1dht_1stats_1alert(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht_stats_alert *arg1 = (libtorrent::dht_stats_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::incoming_request_alert *) 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 = (libtorrent::incoming_request_alert *) 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((const 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 = (libtorrent::incoming_request_alert *) 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 = (libtorrent::incoming_request_alert *) 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 = (libtorrent::incoming_request_alert *) 0 ;
  libtorrent::peer_request *arg2 = (libtorrent::peer_request *) 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 = (libtorrent::incoming_request_alert *) 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 = (libtorrent::incoming_request_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_log_alert *) 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 = (libtorrent::dht_log_alert *) 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((const 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 = (libtorrent::dht_log_alert *) 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 = (libtorrent::dht_log_alert *) 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 = (libtorrent::dht_log_alert *) 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 = (libtorrent::dht_log_alert *) 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 = (libtorrent::dht_log_alert *) 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 = (libtorrent::dht_log_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_pkt_alert *) 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 = (libtorrent::dht_pkt_alert *) 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((const 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 = (libtorrent::dht_pkt_alert *) 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 = (libtorrent::dht_pkt_alert *) 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1pkt_1alert_1pkt_1buf(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::dht_pkt_alert *arg1 = (libtorrent::dht_pkt_alert *) 0 ;
  libtorrent::span< char const > result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_pkt_alert **)&jarg1; 
  {
    try {
      result = ((libtorrent::dht_pkt_alert const *)arg1)->pkt_buf();
    } catch (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 >((const libtorrent::span< char const > &)result); 
  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 = (libtorrent::dht_pkt_alert *) 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 = (libtorrent::dht_pkt_alert *) 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 = (libtorrent::dht_pkt_alert *) 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((const libtorrent::udp::endpoint &)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 = (libtorrent::dht_pkt_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_get_peers_reply_alert *) 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 = (libtorrent::dht_get_peers_reply_alert *) 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((const 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 = (libtorrent::dht_get_peers_reply_alert *) 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 = (libtorrent::dht_get_peers_reply_alert *) 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 = (libtorrent::dht_get_peers_reply_alert *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 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 = (libtorrent::dht_get_peers_reply_alert *) 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 = (libtorrent::dht_get_peers_reply_alert *) 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 = (libtorrent::dht_get_peers_reply_alert *) 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 >((const 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 = (libtorrent::dht_get_peers_reply_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_direct_response_alert *) 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 = (libtorrent::dht_direct_response_alert *) 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((const 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 = (libtorrent::dht_direct_response_alert *) 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 = (libtorrent::dht_direct_response_alert *) 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 = (libtorrent::dht_direct_response_alert *) 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((const 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 = (libtorrent::dht_direct_response_alert *) 0 ;
  int64_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht_direct_response_alert **)&jarg1; 
  {
    try {
      result = (int64_t)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;
    }
  }
  jresult = (jlong)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 = (libtorrent::dht_direct_response_alert *) 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((const 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 = (libtorrent::dht_direct_response_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::picker_log_alert *) 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 = (libtorrent::picker_log_alert *) 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((const 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 = (libtorrent::picker_log_alert *) 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 = (libtorrent::picker_log_alert *) 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 = (libtorrent::picker_log_alert *) 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 = (libtorrent::picker_log_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::session_error_alert *) 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 = (libtorrent::session_error_alert *) 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((const 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 = (libtorrent::session_error_alert *) 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 = (libtorrent::session_error_alert *) 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 = (libtorrent::session_error_alert *) 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 = (libtorrent::session_error_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_live_nodes_alert *) 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 = (libtorrent::dht_live_nodes_alert *) 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((const 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 = (libtorrent::dht_live_nodes_alert *) 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 = (libtorrent::dht_live_nodes_alert *) 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 = (libtorrent::dht_live_nodes_alert *) 0 ;
  libtorrent::sha1_hash *arg2 = (libtorrent::sha1_hash *) 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 = (libtorrent::dht_live_nodes_alert *) 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 = (libtorrent::dht_live_nodes_alert *) 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 = (libtorrent::dht_live_nodes_alert *) 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 > >((const 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 = (libtorrent::dht_live_nodes_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::session_stats_header_alert *) 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 = (libtorrent::session_stats_header_alert *) 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((const 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 = (libtorrent::session_stats_header_alert *) 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 = (libtorrent::session_stats_header_alert *) 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 = (libtorrent::session_stats_header_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::dht_sample_infohashes_alert *) 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 = (libtorrent::dht_sample_infohashes_alert *) 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((const 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 = (libtorrent::dht_sample_infohashes_alert *) 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 = (libtorrent::dht_sample_infohashes_alert *) 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 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 = (libtorrent::dht_sample_infohashes_alert *) 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 = (libtorrent::dht_sample_infohashes_alert *) 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 = (libtorrent::dht_sample_infohashes_alert *) 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 >((const 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 = (libtorrent::dht_sample_infohashes_alert *) 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 = (libtorrent::dht_sample_infohashes_alert *) 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 > >((const 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 = (libtorrent::dht_sample_infohashes_alert *) 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((const 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 = (libtorrent::dht_sample_infohashes_alert *) 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 = (libtorrent::dht_sample_infohashes_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::block_uploaded_alert *) 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 = (libtorrent::block_uploaded_alert *) 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((const 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 = (libtorrent::block_uploaded_alert *) 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 = (libtorrent::block_uploaded_alert *) 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 = (libtorrent::block_uploaded_alert *) 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 = (libtorrent::block_uploaded_alert *) 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 = (libtorrent::block_uploaded_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::alerts_dropped_alert *) 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 = (libtorrent::alerts_dropped_alert *) 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((const 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 = (libtorrent::alerts_dropped_alert *) 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 = (libtorrent::alerts_dropped_alert *) 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) {
  libtorrent::alerts_dropped_alert *arg1 = (libtorrent::alerts_dropped_alert *) 0 ;
  std::bitset< 97 > *arg2 = (std::bitset< 97 > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alerts_dropped_alert **)&jarg1; 
  arg2 = *(std::bitset< 97 > **)&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 = (libtorrent::alerts_dropped_alert *) 0 ;
  std::bitset< 97 > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::alerts_dropped_alert **)&jarg1; 
  result = (std::bitset< 97 > *)& ((arg1)->dropped_alerts);
  *(std::bitset< 97 > **)&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 = (libtorrent::alerts_dropped_alert *) 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 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)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 = (libtorrent::socks5_alert *) 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 = (libtorrent::socks5_alert *) 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((const 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 = (libtorrent::socks5_alert *) 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 = (libtorrent::socks5_alert *) 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 = (libtorrent::socks5_alert *) 0 ;
  libtorrent::error_code *arg2 = (libtorrent::error_code *) 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 = (libtorrent::socks5_alert *) 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 = (libtorrent::socks5_alert *) 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 = (libtorrent::socks5_alert *) 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_socks5_1alert_1ip_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2) {
  libtorrent::socks5_alert *arg1 = (libtorrent::socks5_alert *) 0 ;
  libtorrent::aux::noexcept_movable< libtorrent::tcp::endpoint > *arg2 = (libtorrent::aux::noexcept_movable< libtorrent::tcp::endpoint > *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::socks5_alert **)&jarg1; 
  arg2 = *(libtorrent::aux::noexcept_movable< libtorrent::tcp::endpoint > **)&jarg2; 
  if (arg1) (arg1)->ip = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_socks5_1alert_1ip_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::socks5_alert *arg1 = (libtorrent::socks5_alert *) 0 ;
  libtorrent::aux::noexcept_movable< libtorrent::tcp::endpoint > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::socks5_alert **)&jarg1; 
  result = (libtorrent::aux::noexcept_movable< libtorrent::tcp::endpoint > *)& ((arg1)->ip);
  *(libtorrent::aux::noexcept_movable< libtorrent::tcp::endpoint > **)&jresult = 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 = (libtorrent::socks5_alert *) 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 jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_performance_1warning_1str(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jstring jresult = 0 ;
  libtorrent::performance_alert::performance_warning_t arg1 ;
  char *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = (libtorrent::performance_alert::performance_warning_t)jarg1; 
  {
    try {
      result = (char *)libtorrent::performance_warning_str(arg1);
    } 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_default_1int_1value(JNIEnv *jenv, jclass jcls, jint jarg1) {
  jint jresult = 0 ;
  int arg1 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  arg1 = (int)jarg1; 
  {
    try {
      result = (int)libtorrent::default_int_value(arg1);
    } catch (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_setting_1by_1name(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::string_view arg1 ;
  libtorrent::string_view *argp1 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  argp1 = *(libtorrent::string_view **)&jarg1; 
  if (!argp1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return 0;
  }
  arg1 = *argp1; 
  {
    try {
      result = (int)libtorrent::setting_by_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 = (jint)result; 
  return jresult;
}


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((const libtorrent::settings_pack &)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 & reference 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 = (libtorrent::settings_pack *) 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 = (const char *)jenv->GetStringUTFChars(jarg3, 0); 
  if (!arg3_pstr) return ;
  (&arg3)->assign(arg3_pstr);
  jenv->ReleaseStringUTFChars(jarg3, arg3_pstr); 
  {
    try {
      (arg1)->set_str(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_1int(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3) {
  libtorrent::settings_pack *arg1 = (libtorrent::settings_pack *) 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 = (libtorrent::settings_pack *) 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 = (libtorrent::settings_pack *) 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 = (libtorrent::settings_pack *) 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 = (libtorrent::settings_pack *) 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 = (libtorrent::settings_pack *) 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 = (libtorrent::settings_pack *) 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 = (libtorrent::settings_pack *) 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_1coalesce_1reads_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::coalesce_reads;
  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_1volatile_1read_1cache_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::volatile_read_cache;
  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_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_1cache_1expiry_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::cache_expiry;
  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_1read_1cache_1line_1size_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::read_cache_line_size;
  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_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_1checking_1mem_1usage_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::checking_mem_usage;
  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_1num_1string_1settings_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  libtorrent::settings_pack::settings_counts_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::settings_counts_t)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 ;
  libtorrent::settings_pack::settings_counts_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::settings_counts_t)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 ;
  libtorrent::settings_pack::settings_counts_t result;
  
  (void)jenv;
  (void)jcls;
  result = (libtorrent::settings_pack::settings_counts_t)libtorrent::settings_pack::num_int_settings;
  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_1deprecated_1disable_1os_1cache_1for_1aligned_1files_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::deprecated_disable_os_cache_for_aligned_files;
  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_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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1settings_1pack(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::settings_pack *arg1 = (libtorrent::settings_pack *) 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 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_peer_1class_1type_1filter_1add(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, int jarg3) {
  libtorrent::peer_class_type_filter *arg1 = (libtorrent::peer_class_type_filter *) 0 ;
  libtorrent::peer_class_type_filter::socket_type_t arg2 ;
  peer_class_t arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_type_filter **)&jarg1; 
  arg2 = (libtorrent::peer_class_type_filter::socket_type_t)jarg2; 
  {
    arg3 = peer_class_t(static_cast<std::uint32_t>(jarg3));
  }
  {
    try {
      (arg1)->add(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_peer_1class_1type_1filter_1remove(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, int jarg3) {
  libtorrent::peer_class_type_filter *arg1 = (libtorrent::peer_class_type_filter *) 0 ;
  libtorrent::peer_class_type_filter::socket_type_t arg2 ;
  peer_class_t arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_type_filter **)&jarg1; 
  arg2 = (libtorrent::peer_class_type_filter::socket_type_t)jarg2; 
  {
    arg3 = peer_class_t(static_cast<std::uint32_t>(jarg3));
  }
  {
    try {
      (arg1)->remove(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_peer_1class_1type_1filter_1disallow(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, int jarg3) {
  libtorrent::peer_class_type_filter *arg1 = (libtorrent::peer_class_type_filter *) 0 ;
  libtorrent::peer_class_type_filter::socket_type_t arg2 ;
  peer_class_t arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_type_filter **)&jarg1; 
  arg2 = (libtorrent::peer_class_type_filter::socket_type_t)jarg2; 
  {
    arg3 = peer_class_t(static_cast<std::uint32_t>(jarg3));
  }
  {
    try {
      (arg1)->disallow(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_peer_1class_1type_1filter_1allow(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, int jarg3) {
  libtorrent::peer_class_type_filter *arg1 = (libtorrent::peer_class_type_filter *) 0 ;
  libtorrent::peer_class_type_filter::socket_type_t arg2 ;
  peer_class_t arg3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::peer_class_type_filter **)&jarg1; 
  arg2 = (libtorrent::peer_class_type_filter::socket_type_t)jarg2; 
  {
    arg3 = peer_class_t(static_cast<std::uint32_t>(jarg3));
  }
  {
    try {
      (arg1)->allow(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_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 = (libtorrent::peer_class_type_filter *) 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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_op_1eq_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jboolean jresult = 0 ;
  libtorrent::peer_class_type_filter *arg1 = 0 ;
  libtorrent::peer_class_type_filter *arg2 = 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::peer_class_type_filter **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::peer_class_type_filter const & reference is null");
    return 0;
  } 
  arg2 = *(libtorrent::peer_class_type_filter **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::peer_class_type_filter const & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)operator ==((libtorrent::peer_class_type_filter const &)*arg1,(libtorrent::peer_class_type_filter 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_1peer_1class_1type_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::peer_class_type_filter *arg1 = (libtorrent::peer_class_type_filter *) 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 jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_op_1lte(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;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::address const & reference is null");
    return 0;
  } 
  arg2 = *(libtorrent::address **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::address const & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)libtorrent::operator <=((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 = (jboolean)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 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 = (libtorrent::ip_filter *) 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 & reference is null");
    return ;
  } 
  arg3 = *(libtorrent::address **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::address const & reference 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 = (libtorrent::ip_filter *) 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 & reference 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1ip_1filter(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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1ip_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::ip_filter *arg1 = (libtorrent::ip_filter *) 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 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 = (libtorrent::port_filter *) 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 = (libtorrent::port_filter *) 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_1port_1filter(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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1port_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::port_filter *arg1 = (libtorrent::port_filter *) 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 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 & reference 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 = (libtorrent::session_handle *) 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_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_dht_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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1save_1state_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  libtorrent::entry *arg2 = 0 ;
  libtorrent::save_state_flags_t arg3 ;
  libtorrent::save_state_flags_t *argp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::entry **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry & reference is null");
    return ;
  } 
  argp3 = *(libtorrent::save_state_flags_t **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::save_state_flags_t");
    return ;
  }
  arg3 = *argp3; 
  {
    try {
      ((libtorrent::session_handle const *)arg1)->save_state(*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_1save_1state_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  libtorrent::entry *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::entry **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry & reference is null");
    return ;
  } 
  {
    try {
      ((libtorrent::session_handle const *)arg1)->save_state(*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_1load_1state_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  libtorrent::bdecode_node *arg2 = 0 ;
  libtorrent::save_state_flags_t arg3 ;
  libtorrent::save_state_flags_t *argp3 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::bdecode_node **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & reference is null");
    return ;
  } 
  argp3 = *(libtorrent::save_state_flags_t **)&jarg3; 
  if (!argp3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::save_state_flags_t");
    return ;
  }
  arg3 = *argp3; 
  {
    try {
      (arg1)->load_state((libtorrent::bdecode_node 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_1load_1state_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  libtorrent::bdecode_node *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::bdecode_node **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->load_state((libtorrent::bdecode_node 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_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 = (libtorrent::session_handle *) 0 ;
  std::vector< libtorrent::torrent_status > *arg2 = (std::vector< libtorrent::torrent_status > *) 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,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 = (libtorrent::session_handle *) 0 ;
  std::vector< libtorrent::torrent_status > *arg2 = (std::vector< libtorrent::torrent_status > *) 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 = (libtorrent::session_handle *) 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(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 = (libtorrent::session_handle *) 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 = (libtorrent::session_handle *) 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 = (libtorrent::session_handle *) 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1find_1torrent(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 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 & reference 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((const 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 = (libtorrent::session_handle *) 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 >((const 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 = (libtorrent::session_handle *) 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 & reference is null");
    return 0;
  } 
  arg3 = *(libtorrent::error_code **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & reference 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((const 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 = (libtorrent::session_handle *) 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 & reference 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 = (libtorrent::session_handle *) 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 = (libtorrent::session_handle *) 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 = (libtorrent::session_handle *) 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 jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1disk_1cache_1no_1pieces_1get(JNIEnv *jenv, jclass jcls) {
  jint jresult = 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  result = (int)libtorrent::session_handle::disk_cache_no_pieces;
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1set_1dht_1settings(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  libtorrent::dht::dht_settings *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(libtorrent::dht::dht_settings **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::dht::dht_settings const & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->set_dht_settings((libtorrent::dht::dht_settings 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_session_1handle_1is_1dht_1running(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1get_1dht_1settings(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  libtorrent::dht::dht_settings result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    try {
      result = ((libtorrent::session_handle const *)arg1)->get_dht_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::dht::dht_settings **)&jresult = new libtorrent::dht::dht_settings((const libtorrent::dht::dht_settings &)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 = (libtorrent::session_handle *) 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 & reference 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 = (libtorrent::session_handle *) 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 & reference 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 = (libtorrent::session_handle *) 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(arg2);
    } catch (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((const 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 = (libtorrent::session_handle *) 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 & reference 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_1announce_1_1SWIG_10(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3, jint jarg4) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  libtorrent::sha1_hash *arg2 = 0 ;
  int arg3 ;
  libtorrent::dht::announce_flags_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 & reference is null");
    return ;
  } 
  arg3 = (int)jarg3; 
  arg4 = (libtorrent::dht::announce_flags_t)jarg4; 
  {
    try {
      (arg1)->dht_announce((libtorrent::sha1_hash 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_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jint jarg3) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 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 & reference is null");
    return ;
  } 
  arg3 = (int)jarg3; 
  {
    try {
      (arg1)->dht_announce((libtorrent::sha1_hash 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_1_1SWIG_12(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->dht_announce((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 = (libtorrent::session_handle *) 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 & reference 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 = (libtorrent::session_handle *) 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 & reference is null");
    return ;
  } 
  arg3 = *(libtorrent::sha1_hash **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & reference 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_) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 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 & reference is null");
    return ;
  } 
  arg3 = *(libtorrent::entry **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry const & reference 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 = (libtorrent::session_handle *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->set_ip_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_1ip_1filter(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 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((const 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 = (libtorrent::session_handle *) 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 & reference 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 int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1global_1peer_1class_1id_1get(JNIEnv *jenv, jclass jcls) {
  int jresult = 0 ;
  peer_class_t result;
  
  (void)jenv;
  (void)jcls;
  result = libtorrent::session_handle::global_peer_class_id;
  {
    jresult = static_cast<std::int32_t>(static_cast<std::uint32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1tcp_1peer_1class_1id_1get(JNIEnv *jenv, jclass jcls) {
  int jresult = 0 ;
  peer_class_t result;
  
  (void)jenv;
  (void)jcls;
  result = libtorrent::session_handle::tcp_peer_class_id;
  {
    jresult = static_cast<std::int32_t>(static_cast<std::uint32_t>(result));
  }
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1local_1peer_1class_1id_1get(JNIEnv *jenv, jclass jcls) {
  int jresult = 0 ;
  peer_class_t result;
  
  (void)jenv;
  (void)jcls;
  result = libtorrent::session_handle::local_peer_class_id;
  {
    jresult = static_cast<std::int32_t>(static_cast<std::uint32_t>(result));
  }
  return jresult;
}


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 = (libtorrent::session_handle *) 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 = (libtorrent::session_handle *) 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 = (libtorrent::session_handle *) 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 = (libtorrent::session_handle *) 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 & reference 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 = (libtorrent::session_handle *) 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((const 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 = (libtorrent::session_handle *) 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 & reference 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 = (libtorrent::session_handle *) 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((const libtorrent::peer_class_type_filter &)result); 
  return jresult;
}


SWIGEXPORT int JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1create_1peer_1class(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2) {
  int jresult = 0 ;
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  char *arg2 = (char *) 0 ;
  peer_class_t result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = 0;
  if (jarg2) {
    arg2 = (char *)jenv->GetStringUTFChars(jarg2, 0);
    if (!arg2) return 0;
  }
  {
    try {
      result = (arg1)->create_peer_class((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 = static_cast<std::int32_t>(static_cast<std::uint32_t>(result));
  }
  if (arg2) jenv->ReleaseStringUTFChars(jarg2, (const char *)arg2);
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1delete_1peer_1class(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  peer_class_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    arg2 = peer_class_t(static_cast<std::uint32_t>(jarg2));
  }
  {
    try {
      (arg1)->delete_peer_class(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(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  peer_class_t arg2 ;
  libtorrent::peer_class_info result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    arg2 = peer_class_t(static_cast<std::uint32_t>(jarg2));
  }
  {
    try {
      result = ((libtorrent::session_handle const *)arg1)->get_peer_class(arg2);
    } catch (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 = new libtorrent::peer_class_info((const libtorrent::peer_class_info &)result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1set_1peer_1class(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jlong jarg3, jobject jarg3_) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  peer_class_t arg2 ;
  libtorrent::peer_class_info *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    arg2 = peer_class_t(static_cast<std::uint32_t>(jarg2));
  }
  arg3 = *(libtorrent::peer_class_info **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::peer_class_info const & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->set_peer_class(arg2,(libtorrent::peer_class_info 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_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 = (libtorrent::session_handle *) 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 & reference 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,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 = (libtorrent::session_handle *) 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 & reference 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 = (libtorrent::session_handle *) 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 & reference 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 = (libtorrent::session_handle *) 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((const 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 = (libtorrent::session_handle *) 0 ;
  std::vector< libtorrent::alert * > *arg2 = (std::vector< libtorrent::alert * > *) 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_1add_1port_1mapping(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2, jint jarg3, jint jarg4) {
  jlong jresult = 0 ;
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  libtorrent::portmap_protocol arg2 ;
  int arg3 ;
  int arg4 ;
  std::vector< port_mapping_t > 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 = (arg1)->add_port_mapping(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< port_mapping_t > **)&jresult = new std::vector< port_mapping_t >((const std::vector< port_mapping_t > &)result); 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1handle_1delete_1port_1mapping(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  port_mapping_t arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  {
    arg2 = port_mapping_t(static_cast<int>(jarg2));
  }
  {
    try {
      (arg1)->delete_port_mapping(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_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 = (libtorrent::session_handle *) 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(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 = (libtorrent::session_handle *) 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 = (libtorrent::session_handle *) 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  std::vector< int8_t > *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference is null");
    return ;
  } 
  arg3 = *(std::vector< int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference 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_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 = (libtorrent::session_handle *) 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  std::vector< int8_t > *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::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference is null");
    return ;
  } 
  arg3 = *(std::vector< int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference is null");
    return ;
  } 
  arg4 = *(libtorrent::entry **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry & reference is null");
    return ;
  } 
  arg5 = *(std::vector< int8_t > **)&jarg5;
  if (!arg5) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference 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_1direct_1request_1_1SWIG_11(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 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 & reference is null");
    return ;
  } 
  arg3 = *(libtorrent::entry **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry const & reference is null");
    return ;
  } 
  arg4 = (int64_t)jarg4; 
  {
    try {
      libtorrent_session_handle_dht_direct_request__SWIG_1(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 = (libtorrent::session_handle *) 0 ;
  int64_t arg2 ;
  libtorrent::alert *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = (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 = (libtorrent::session_handle *) 0 ;
  alert_notify_callback *arg2 = (alert_notify_callback *) 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_1add_1extension(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_handle *arg1 = (libtorrent::session_handle *) 0 ;
  swig_plugin *arg2 = (swig_plugin *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_handle **)&jarg1; 
  arg2 = *(swig_plugin **)&jarg2; 
  {
    try {
      libtorrent_session_handle_add_extension(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 = (libtorrent::session_handle *) 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 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 = (libtorrent::dht::dht_state *) 0 ;
  libtorrent::dht::node_ids_t *arg2 = (libtorrent::dht::node_ids_t *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::dht::dht_state **)&jarg1; 
  arg2 = *(libtorrent::dht::node_ids_t **)&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 = (libtorrent::dht::dht_state *) 0 ;
  libtorrent::dht::node_ids_t *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_state **)&jarg1; 
  result = (libtorrent::dht::node_ids_t *)& ((arg1)->nids);
  *(libtorrent::dht::node_ids_t **)&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 = (libtorrent::dht::dht_state *) 0 ;
  std::vector< libtorrent::udp::endpoint > *arg2 = (std::vector< libtorrent::udp::endpoint > *) 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 = (libtorrent::dht::dht_state *) 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 = (libtorrent::dht::dht_state *) 0 ;
  std::vector< libtorrent::udp::endpoint > *arg2 = (std::vector< libtorrent::udp::endpoint > *) 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 = (libtorrent::dht::dht_state *) 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 = (libtorrent::dht::dht_state *) 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 = (libtorrent::dht::dht_state *) 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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1peers_1reply_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_peers_reply = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1peers_1reply_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->max_peers_reply);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1search_1branching_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->search_branching = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1search_1branching_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->search_branching);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1fail_1count_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_fail_count = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1fail_1count_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->max_fail_count);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1torrents_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_torrents = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1torrents_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->max_torrents);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1dht_1items_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_dht_items = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1dht_1items_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->max_dht_items);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1peers_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_peers = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1peers_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->max_peers);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1torrent_1search_1reply_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_torrent_search_reply = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1torrent_1search_1reply_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->max_torrent_search_reply);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1restrict_1routing_1ips_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->restrict_routing_ips = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1restrict_1routing_1ips_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (bool) ((arg1)->restrict_routing_ips);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1restrict_1search_1ips_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->restrict_search_ips = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1restrict_1search_1ips_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (bool) ((arg1)->restrict_search_ips);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1extended_1routing_1table_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->extended_routing_table = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1extended_1routing_1table_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (bool) ((arg1)->extended_routing_table);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1aggressive_1lookups_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->aggressive_lookups = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1aggressive_1lookups_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (bool) ((arg1)->aggressive_lookups);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1privacy_1lookups_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->privacy_lookups = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1privacy_1lookups_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (bool) ((arg1)->privacy_lookups);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1enforce_1node_1id_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->enforce_node_id = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1enforce_1node_1id_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (bool) ((arg1)->enforce_node_id);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1ignore_1dark_1internet_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->ignore_dark_internet = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1ignore_1dark_1internet_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (bool) ((arg1)->ignore_dark_internet);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1block_1timeout_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->block_timeout = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1block_1timeout_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->block_timeout);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1block_1ratelimit_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->block_ratelimit = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1block_1ratelimit_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->block_ratelimit);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1read_1only_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->read_only = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1read_1only_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (bool) ((arg1)->read_only);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1item_1lifetime_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->item_lifetime = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1item_1lifetime_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->item_lifetime);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1upload_1rate_1limit_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->upload_rate_limit = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1upload_1rate_1limit_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->upload_rate_limit);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1sample_1infohashes_1interval_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->sample_infohashes_interval = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1sample_1infohashes_1interval_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->sample_infohashes_interval);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1infohashes_1sample_1count_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jint jarg2) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  arg2 = (int)jarg2; 
  if (arg1) (arg1)->max_infohashes_sample_count = arg2;
}


SWIGEXPORT jint JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_dht_1settings_1max_1infohashes_1sample_1count_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jint jresult = 0 ;
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  int result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::dht_settings **)&jarg1; 
  result = (int) ((arg1)->max_infohashes_sample_count);
  jresult = (jint)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1dht_1settings(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::dht::dht_settings *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::dht::dht_settings *)new libtorrent::dht::dht_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::dht::dht_settings **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1dht_1settings(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht::dht_settings *arg1 = (libtorrent::dht::dht_settings *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht::dht_settings **)&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_settings_1prefer_1verified_1node_1ids_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jboolean jarg2) {
  libtorrent::dht::settings *arg1 = (libtorrent::dht::settings *) 0 ;
  bool arg2 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::settings **)&jarg1; 
  arg2 = jarg2 ? true : false; 
  if (arg1) (arg1)->prefer_verified_node_ids = arg2;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_settings_1prefer_1verified_1node_1ids_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jboolean jresult = 0 ;
  libtorrent::dht::settings *arg1 = (libtorrent::dht::settings *) 0 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::dht::settings **)&jarg1; 
  result = (bool) ((arg1)->prefer_verified_node_ids);
  jresult = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1settings(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  libtorrent::dht::settings *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (libtorrent::dht::settings *)new libtorrent::dht::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::dht::settings **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1settings(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::dht::settings *arg1 = (libtorrent::dht::settings *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(libtorrent::dht::settings **)&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((const 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((const 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 = (libtorrent::session_proxy *) 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 & reference 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_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 & reference 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 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 & reference 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 = (libtorrent::session_params *) 0 ;
  libtorrent::settings_pack *arg2 = (libtorrent::settings_pack *) 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 = (libtorrent::session_params *) 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_1settings_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  libtorrent::session_params *arg1 = (libtorrent::session_params *) 0 ;
  libtorrent::dht::dht_settings *arg2 = (libtorrent::dht::dht_settings *) 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  arg2 = *(libtorrent::dht::dht_settings **)&jarg2; 
  if (arg1) (arg1)->dht_settings = *arg2;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_session_1params_1dht_1settings_1get(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session_params *arg1 = (libtorrent::session_params *) 0 ;
  libtorrent::dht::dht_settings *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session_params **)&jarg1; 
  result = (libtorrent::dht::dht_settings *)& ((arg1)->dht_settings);
  *(libtorrent::dht::dht_settings **)&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 = (libtorrent::session_params *) 0 ;
  libtorrent::dht::dht_state *arg2 = (libtorrent::dht::dht_state *) 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 = (libtorrent::session_params *) 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_delete_1session_1params(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  libtorrent::session_params *arg1 = (libtorrent::session_params *) 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_read_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 & reference 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::read_session_params((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::session_params **)&jresult = new libtorrent::session_params((const libtorrent::session_params &)result); 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_read_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 & reference is null");
    return 0;
  } 
  {
    try {
      result = libtorrent::read_session_params((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((const libtorrent::session_params &)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 & reference 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 const *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 & reference 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 const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (libtorrent::session *)new libtorrent::session((libtorrent::session_params 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::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 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_14(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  jlong jresult = 0 ;
  libtorrent::settings_pack *arg1 = 0 ;
  libtorrent::session_flags_t arg2 ;
  libtorrent::session_flags_t const *argp2 ;
  libtorrent::session *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::settings_pack **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::settings_pack const & reference 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 const");
    return 0;
  }
  arg2 = *argp2; 
  {
    try {
      result = (libtorrent::session *)new libtorrent::session((libtorrent::settings_pack 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::session **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1_1SWIG_15(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::settings_pack *arg1 = 0 ;
  libtorrent::session *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::settings_pack **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::settings_pack const & reference is null");
    return 0;
  } 
  {
    try {
      result = (libtorrent::session *)new libtorrent::session((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 **)&jresult = result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1session_1_1SWIG_16(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::session *arg1 = 0 ;
  libtorrent::session *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::session **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::session && reference is null");
    return 0;
  } 
  {
    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 = (libtorrent::session *) 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 = (libtorrent::session *) 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((const libtorrent::session_proxy &)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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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(arg2);
    } catch (std::exception& e) {
      SWIG_JavaThrowException(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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 & reference 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 = (libtorrent::peer_connection_handle *) 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((const 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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((const 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 = (libtorrent::peer_connection_handle *) 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 & reference 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,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 = (libtorrent::peer_connection_handle *) 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 & reference 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 & reference 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 0 ;
  char *arg2 = (char *) 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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 & reference 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 = (libtorrent::peer_connection_handle *) 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 & reference 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 = (libtorrent::peer_connection_handle *) 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 & reference 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 = (libtorrent::peer_connection_handle *) 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 = (libtorrent::peer_connection_handle *) 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(arg1);
    } catch (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 = (libtorrent::bt_peer_connection_handle *) 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 = (libtorrent::bt_peer_connection_handle *) 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 = (libtorrent::bt_peer_connection_handle *) 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 = (libtorrent::bt_peer_connection_handle *) 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 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::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 & reference 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_11(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 & reference 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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_create_1torrent_1optimize_1alignment_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::optimize_alignment;
  *(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_1merkle_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::merkle;
  *(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_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_1mutable_1torrent_1support_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::mutable_torrent_support;
  *(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, jint jarg3, jlong jarg4, jobject jarg4_, jint jarg5) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  libtorrent::create_flags_t arg4 ;
  int arg5 ;
  libtorrent::create_flags_t *argp4 ;
  libtorrent::create_torrent *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg4_;
  arg1 = *(libtorrent::file_storage **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_storage & reference is null");
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  argp4 = *(libtorrent::create_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::create_flags_t");
    return 0;
  }
  arg4 = *argp4; 
  arg5 = (int)jarg5; 
  {
    try {
      result = (libtorrent::create_torrent *)new libtorrent::create_torrent(*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;
    }
  }
  *(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, jint jarg3, jlong jarg4, jobject jarg4_) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  libtorrent::create_flags_t arg4 ;
  libtorrent::create_flags_t *argp4 ;
  libtorrent::create_torrent *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg4_;
  arg1 = *(libtorrent::file_storage **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::file_storage & reference is null");
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  argp4 = *(libtorrent::create_flags_t **)&jarg4; 
  if (!argp4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::create_flags_t");
    return 0;
  }
  arg4 = *argp4; 
  {
    try {
      result = (libtorrent::create_torrent *)new libtorrent::create_torrent(*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;
    }
  }
  *(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_, jint jarg2, jint jarg3) {
  jlong jresult = 0 ;
  libtorrent::file_storage *arg1 = 0 ;
  int arg2 ;
  int arg3 ;
  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 & reference is null");
    return 0;
  } 
  arg2 = (int)jarg2; 
  arg3 = (int)jarg3; 
  {
    try {
      result = (libtorrent::create_torrent *)new libtorrent::create_torrent(*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::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_, 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 & reference 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_14(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 & reference 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_15(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 & reference 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 = (libtorrent::create_torrent *) 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 = (libtorrent::create_torrent *) 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((const 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 = (libtorrent::create_torrent *) 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 = (libtorrent::create_torrent *) 0 ;
  char *arg2 = (char *) 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 = (libtorrent::create_torrent *) 0 ;
  char *arg2 = (char *) 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_1hash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jlong jarg3, jobject jarg3_) {
  libtorrent::create_torrent *arg1 = (libtorrent::create_torrent *) 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 & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->set_hash(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_1set_1file_1hash(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, int jarg2, jlong jarg3, jobject jarg3_) {
  libtorrent::create_torrent *arg1 = (libtorrent::create_torrent *) 0 ;
  file_index_t arg2 ;
  libtorrent::sha1_hash *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    arg2 = file_index_t(static_cast<std::int32_t>(jarg2));
  }
  arg3 = *(libtorrent::sha1_hash **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::sha1_hash const & reference is null");
    return ;
  } 
  {
    try {
      (arg1)->set_file_hash(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 = (libtorrent::create_torrent *) 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(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 = (libtorrent::create_torrent *) 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 = (libtorrent::create_torrent *) 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 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 = (libtorrent::create_torrent *) 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 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 = (libtorrent::create_torrent *) 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 = (libtorrent::create_torrent *) 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(arg2);
    } catch (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_1torrent_1merkle_1tree(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_) {
  jlong jresult = 0 ;
  libtorrent::create_torrent *arg1 = (libtorrent::create_torrent *) 0 ;
  std::vector< libtorrent::sha1_hash > *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  {
    try {
      result = (std::vector< libtorrent::sha1_hash > *) &((libtorrent::create_torrent const *)arg1)->merkle_tree();
    } catch (std::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 = 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 = (libtorrent::create_torrent *) 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(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 = (libtorrent::create_torrent *) 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 = (const char *)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 = (libtorrent::create_torrent *) 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 = (const char *)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(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jint jarg3) {
  libtorrent::create_torrent *arg1 = (libtorrent::create_torrent *) 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 = (const char *)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(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 = (libtorrent::create_torrent *) 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 = (const char *)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 = (libtorrent::create_torrent *) 0 ;
  std::vector< int8_t > *arg2 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  arg1 = *(libtorrent::create_torrent **)&jarg1; 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > const & reference 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_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 & reference is null");
    return ;
  } 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = (const char *)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,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 & reference is null");
    return ;
  } 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = (const char *)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_set_1piece_1hashes(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jstring jarg2, jlong jarg3, jobject jarg3_) {
  libtorrent::create_torrent *arg1 = 0 ;
  std::string *arg2 = 0 ;
  libtorrent::error_code *arg3 = 0 ;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg3_;
  arg1 = *(libtorrent::create_torrent **)&jarg1;
  if (!arg1) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::create_torrent & reference is null");
    return ;
  } 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = (const char *)jenv->GetStringUTFChars(jarg2, 0); 
  if (!arg2_pstr) return ;
  std::string arg2_str(arg2_pstr);
  arg2 = &arg2_str;
  jenv->ReleaseStringUTFChars(jarg2, arg2_pstr); 
  arg3 = *(libtorrent::error_code **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::error_code & reference is null");
    return ;
  } 
  {
    try {
      libtorrent::set_piece_hashes(*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 jstring JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_generate_1fingerprint(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 = (const char *)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(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 jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_ed25519_1create_1seed(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  std::vector< int8_t > 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::vector< int8_t > **)&jresult = new std::vector< int8_t >((const std::vector< int8_t > &)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 > & reference 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 > >((const 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 > & reference is null");
    return 0;
  } 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference is null");
    return 0;
  } 
  arg3 = *(std::vector< int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference 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 >((const 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 > & reference is null");
    return 0;
  } 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference is null");
    return 0;
  } 
  arg3 = *(std::vector< int8_t > **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference 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 > & reference is null");
    return 0;
  } 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference 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 >((const 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 > & reference is null");
    return 0;
  } 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference 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 >((const 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 > & reference is null");
    return 0;
  } 
  arg2 = *(std::vector< int8_t > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< int8_t > & reference 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 >((const 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 = (alert_notify_callback *) 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 = (alert_notify_callback *) 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 = (alert_notify_callback *) 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 = (add_files_listener *) 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 = (add_files_listener *) 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 = (const char *)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 = (add_files_listener *) 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 = (const char *)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 = (add_files_listener *) 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 & reference is null");
    return ;
  } 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = (const char *)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,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 = (set_piece_hashes_listener *) 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 = (set_piece_hashes_listener *) 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 = (set_piece_hashes_listener *) 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 = (set_piece_hashes_listener *) 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 & reference is null");
    return ;
  } 
  if(!jarg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "null string");
    return ;
  }
  const char *arg2_pstr = (const char *)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 & reference 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 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 = (const char *)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 void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_delete_1swig_1plugin(JNIEnv *jenv, jclass jcls, jlong jarg1) {
  swig_plugin *arg1 = (swig_plugin *) 0 ;
  
  (void)jenv;
  (void)jcls;
  arg1 = *(swig_plugin **)&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_swig_1plugin_1on_1dht_1request(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_) {
  jboolean jresult = 0 ;
  swig_plugin *arg1 = (swig_plugin *) 0 ;
  libtorrent::string_view arg2 ;
  libtorrent::udp::endpoint *arg3 = 0 ;
  libtorrent::bdecode_node *arg4 = 0 ;
  libtorrent::entry *arg5 = 0 ;
  libtorrent::string_view *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  (void)jarg4_;
  (void)jarg5_;
  arg1 = *(swig_plugin **)&jarg1; 
  argp2 = *(libtorrent::string_view **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return 0;
  }
  arg2 = *argp2; 
  arg3 = *(libtorrent::udp::endpoint **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::udp::endpoint const & reference is null");
    return 0;
  } 
  arg4 = *(libtorrent::bdecode_node **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & reference is null");
    return 0;
  } 
  arg5 = *(libtorrent::entry **)&jarg5;
  if (!arg5) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)(arg1)->on_dht_request(arg2,(libtorrent::udp::endpoint const &)*arg3,(libtorrent::bdecode_node const &)*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 = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jboolean JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_swig_1plugin_1on_1dht_1requestSwigExplicitswig_1plugin(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_, jlong jarg3, jobject jarg3_, jlong jarg4, jobject jarg4_, jlong jarg5, jobject jarg5_) {
  jboolean jresult = 0 ;
  swig_plugin *arg1 = (swig_plugin *) 0 ;
  libtorrent::string_view arg2 ;
  libtorrent::udp::endpoint *arg3 = 0 ;
  libtorrent::bdecode_node *arg4 = 0 ;
  libtorrent::entry *arg5 = 0 ;
  libtorrent::string_view *argp2 ;
  bool result;
  
  (void)jenv;
  (void)jcls;
  (void)jarg1_;
  (void)jarg2_;
  (void)jarg3_;
  (void)jarg4_;
  (void)jarg5_;
  arg1 = *(swig_plugin **)&jarg1; 
  argp2 = *(libtorrent::string_view **)&jarg2; 
  if (!argp2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "Attempt to dereference null libtorrent::string_view");
    return 0;
  }
  arg2 = *argp2; 
  arg3 = *(libtorrent::udp::endpoint **)&jarg3;
  if (!arg3) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::udp::endpoint const & reference is null");
    return 0;
  } 
  arg4 = *(libtorrent::bdecode_node **)&jarg4;
  if (!arg4) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::bdecode_node const & reference is null");
    return 0;
  } 
  arg5 = *(libtorrent::entry **)&jarg5;
  if (!arg5) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "libtorrent::entry & reference is null");
    return 0;
  } 
  {
    try {
      result = (bool)(arg1)->swig_plugin::on_dht_request(arg2,(libtorrent::udp::endpoint const &)*arg3,(libtorrent::bdecode_node const &)*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 = (jboolean)result; 
  return jresult;
}


SWIGEXPORT jlong JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_new_1swig_1plugin(JNIEnv *jenv, jclass jcls) {
  jlong jresult = 0 ;
  swig_plugin *result = 0 ;
  
  (void)jenv;
  (void)jcls;
  {
    try {
      result = (swig_plugin *)new SwigDirector_swig_plugin(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;
    }
  }
  *(swig_plugin **)&jresult = result; 
  return jresult;
}


SWIGEXPORT void JNICALL Java_com_frostwire_jlibtorrent_swig_libtorrent_1jni_swig_1plugin_1director_1connect(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jswig_mem_own, jboolean jweak_global) {
  swig_plugin *obj = *((swig_plugin **)&objarg);
  (void)jcls;
  SwigDirector_swig_plugin *director = static_cast<SwigDirector_swig_plugin *>(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_swig_1plugin_1change_1ownership(JNIEnv *jenv, jclass jcls, jobject jself, jlong objarg, jboolean jtake_or_release) {
  swig_plugin *obj = *((swig_plugin **)&objarg);
  SwigDirector_swig_plugin *director = static_cast<SwigDirector_swig_plugin *>(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_ip_1interface_1interface_1address_1set(JNIEnv *jenv, jclass jcls, jlong jarg1, jobject jarg1_, jlong jarg2, jobject jarg2_) {
  ip_interface *arg1 = (ip_interface *) 0 ;
  libtorrent::address *arg2 = (libtorrent::address *) 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 = (ip_interface *) 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 = (ip_interface *) 0 ;
  libtorrent::address *arg2 = (libtorrent::address *) 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 = (ip_interface *) 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 = (ip_interface *) 0 ;
  std::vector< std::int8_t > *arg2 = (std::vector< std::int8_t > *) 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 = (ip_interface *) 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 = (ip_interface *) 0 ;
  std::vector< std::int8_t > *arg2 = (std::vector< std::int8_t > *) 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 = (ip_interface *) 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 = (ip_interface *) 0 ;
  std::vector< std::int8_t > *arg2 = (std::vector< std::int8_t > *) 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 = (ip_interface *) 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 = (ip_interface *) 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 = (ip_interface *) 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 = (ip_interface *) 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 = (ip_route *) 0 ;
  libtorrent::address *arg2 = (libtorrent::address *) 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 = (ip_route *) 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 = (ip_route *) 0 ;
  libtorrent::address *arg2 = (libtorrent::address *) 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 = (ip_route *) 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 = (ip_route *) 0 ;
  libtorrent::address *arg2 = (libtorrent::address *) 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 = (ip_route *) 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 = (ip_route *) 0 ;
  libtorrent::address *arg2 = (libtorrent::address *) 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 = (ip_route *) 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 = (ip_route *) 0 ;
  std::vector< std::int8_t > *arg2 = (std::vector< std::int8_t > *) 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 = (ip_route *) 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 = (ip_route *) 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 = (ip_route *) 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 = (ip_route *) 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 = (libtorrent::session *) 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 >((const 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 = (libtorrent::session *) 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 >((const std::vector< ip_route > &)result); 
  return jresult;
}


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 = (char *) 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(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 & reference is null");
    return 0;
  } 
  arg2 = *(std::vector< ip_route > **)&jarg2;
  if (!arg2) {
    SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "std::vector< ip_route > & reference 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((const libtorrent::address &)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 = (posix_stat_t *) 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 = (posix_stat_t *) 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 = (posix_stat_t *) 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 = (posix_stat_t *) 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 = (posix_stat_t *) 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 = (posix_stat_t *) 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 = (posix_stat_t *) 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 = (posix_stat_t *) 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 = (posix_stat_t *) 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 = (posix_stat_t *) 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 = (posix_stat_t *) 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 = (posix_wrapper *) 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 = (posix_wrapper *) 0 ;
  char *arg2 = (char *) 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 = (posix_wrapper *) 0 ;
  char *arg2 = (char *) 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 = (posix_wrapper *) 0 ;
  char *arg2 = (char *) 0 ;
  posix_stat_t *arg3 = (posix_stat_t *) 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 = (posix_wrapper *) 0 ;
  char *arg2 = (char *) 0 ;
  posix_stat_t *arg3 = (posix_stat_t *) 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 = (posix_wrapper *) 0 ;
  char *arg2 = (char *) 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 = (posix_wrapper *) 0 ;
  char *arg2 = (char *) 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 = (posix_wrapper *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 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 = (posix_wrapper *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 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 = (posix_wrapper *) 0 ;
  char *arg2 = (char *) 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 = (posix_wrapper *) 0 ;
  char *arg2 = (char *) 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 = (posix_wrapper *) 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_stats_1alert_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::torrent_alert **)&baseptr = *(libtorrent::stats_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_settings_1SWIGUpcast(JNIEnv *jenv, jclass jcls, jlong jarg1) {
    jlong baseptr = 0;
    (void)jenv;
    (void)jcls;
    *(libtorrent::dht::dht_settings **)&baseptr = *(libtorrent::dht::settings **)&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[9] = {
    {
      "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_swig_plugin_on_dht_request", "(Lcom/frostwire/jlibtorrent/swig/swig_plugin;JJJJ)Z" 
    },
    {
      "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