From 0ef140dc6f1e1694120750de66badbc4c7bc9b3f Mon Sep 17 00:00:00 2001
From: Louis Gombert <louisgombert@gmail.com>
Date: Sun, 21 Jul 2024 18:55:25 +0200
Subject: [PATCH 01/10] HogMaker as external project

---
 .github/workflows/build.yml                | 12 +----
 CMakeLists.txt                             | 14 ++++--
 cmake/HogMaker.cmake                       | 58 ----------------------
 netcon/descent3onlineclient/CMakeLists.txt | 15 +++---
 netcon/lanclient/CMakeLists.txt            | 19 +++----
 netcon/mtclient/CMakeLists.txt             | 19 +++----
 scripts/CMakeLists.txt                     | 16 +++---
 tools/CMakeLists.txt                       | 11 +++-
 8 files changed, 56 insertions(+), 108 deletions(-)
 delete mode 100644 cmake/HogMaker.cmake

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index db2295695..fbda3294f 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -46,8 +46,6 @@ jobs:
             name: Linux-x64-clang
           - runner: ubuntu-latest
             preset: linux-cross-arm64
-            cc: gcc
-            cxx: g++++
             name: Linux-cross-arm64
         build_type:
           - Debug
@@ -102,19 +100,11 @@ jobs:
         with:
           vcpkgJsonGlob: vcpkg.json
 
-      - name: Configure cross-compiled build
-        if: ${{ matrix.os.preset == 'linux-cross-arm64' }}
-        run: |
-          cmake --preset linux
-          ninja -f build-${{ matrix.build_type }}.ninja -C builds/linux/ HogMaker
-          cmake --preset linux-cross-arm64 -DHogMaker_DIR=$PWD/builds/linux/ -DBUILD_TESTING=OFF -DENABLE_LOGGER=ON -DFORCE_PORTABLE_INSTALL=ON -DBUILD_EDITOR=OFF -DUSE_EXTERNAL_PLOG=ON
-
       - name: Configure CMake
-        if: ${{ matrix.os.preset != 'linux-cross-arm64' }}
         env:
           CC: ${{ matrix.os.cc }}
           CXX: ${{ matrix.os.cxx }}
-        run: cmake --preset ${{ matrix.os.preset }} -DBUILD_TESTING=ON -DENABLE_LOGGER=ON -DFORCE_PORTABLE_INSTALL=ON -DBUILD_EDITOR=ON -DUSE_EXTERNAL_PLOG=ON
+        run: cmake --preset ${{ matrix.os.preset }} -DENABLE_LOGGER=ON -DFORCE_PORTABLE_INSTALL=ON -DUSE_EXTERNAL_PLOG=ON -DBUILD_EDITOR=ON -DBUILD_TESTING=${{ matrix.os.preset == 'linux-cross-arm64' && 'OFF' || 'ON' }}
 
       - name: Build ${{ matrix.build_type }}
         run: cmake --build --preset ${{ matrix.os.preset }} --config ${{ matrix.build_type }} --verbose
diff --git a/CMakeLists.txt b/CMakeLists.txt
index abe92825a..7b7cf444d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -275,11 +275,17 @@ endif()
 
 add_subdirectory(Descent3)
 
-if (CMAKE_CROSSCOMPILING)
-  find_package(HogMaker REQUIRED)
-else()
-  add_subdirectory(tools)
+# Always build HogMaker natively. Build it as external project,
+include(ExternalProject)
+ExternalProject_Add(HogMaker
+    SOURCE_DIR ${CMAKE_SOURCE_DIR}/tools
+    BINARY_DIR ${CMAKE_BINARY_DIR}/tools
+    INSTALL_COMMAND ""
+)
+if (DEFINED CMAKE_CONFIGURATION_TYPES)
+  set(HogMakerBin_ConfigDir "$<CONFIG>/")
 endif()
+set(HogMakerBin ${CMAKE_BINARY_DIR}/tools/${HogMakerBin_ConfigDir}HogMaker)
 
 add_subdirectory(netcon)
 add_subdirectory(netgames)
diff --git a/cmake/HogMaker.cmake b/cmake/HogMaker.cmake
deleted file mode 100644
index 4f58acc88..000000000
--- a/cmake/HogMaker.cmake
+++ /dev/null
@@ -1,58 +0,0 @@
-# Descent 3
-# Copyright (C) 2024 Descent Developers
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-
-# - Function making a HOG file based on supplied filelist.
-#
-# This module provides function MakeHog() used for building HOG files.
-# MakeHog() registers custom target TARGET which can be used as dependency.
-#
-#   MakeHog(
-#     <TARGET target>
-#     <OUTPUT d3-full-win32.hog>
-#     <INPUT_FILE filelist.txt>
-#     [SEARCH_PATH additional_dirs]
-#     [DEPENDS additional_dependencies]
-#   )
-#
-
-function(MakeHog)
-  set(options)
-  set(oneValueArgs INPUT_FILE OUTPUT TARGET)
-  set(multiValueArgs DEPENDS SEARCH_PATH)
-
-  cmake_parse_arguments(PARSE_ARGV 0
-    "HOG"
-    "${options}"
-    "${oneValueArgs}"
-    "${multiValueArgs}"
-  )
-
-  # Register custom target for tracking dependencies
-  add_custom_target("${HOG_TARGET}"
-    DEPENDS "${HOG_OUTPUT}"
-  )
-
-  add_custom_command(OUTPUT "${HOG_OUTPUT}"
-    COMMAND $<TARGET_FILE:HogMaker>
-      "${HOG_OUTPUT}"
-      "${HOG_INPUT_FILE}"
-      "${HOG_SEARCH_PATH}"
-    DEPENDS HogMaker ${HOG_INPUT_FILE} ${HOG_DEPENDS}
-    COMMENT "Generate ${HOG_OUTPUT}"
-    COMMAND_EXPAND_LISTS
-  )
-endfunction()
diff --git a/netcon/descent3onlineclient/CMakeLists.txt b/netcon/descent3onlineclient/CMakeLists.txt
index 85b2bd9d6..f200ee9b2 100644
--- a/netcon/descent3onlineclient/CMakeLists.txt
+++ b/netcon/descent3onlineclient/CMakeLists.txt
@@ -26,13 +26,14 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
   set_target_properties(Descent3_Online_TCP_IP PROPERTIES SUFFIX ".dylib")
 endif()
 
-include(HogMaker)
-MakeHog(
-  TARGET Descent3_Online_TCP_IP_Hog
-  OUTPUT "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/online/Descent3 Online.d3c"
-  INPUT_FILE "${CMAKE_SOURCE_DIR}/netcon/descent3onlineclient/d3online.d3c.txt"
-  SEARCH_PATH "$<TARGET_FILE_DIR:Descent3_Online_TCP_IP>" "${CMAKE_SOURCE_DIR}/scripts/data/fullhog/"
-  DEPENDS Descent3_Online_TCP_IP
+add_custom_target(Descent3_Online_TCP_IP_Hog
+  COMMAND ${HogMakerBin}
+  "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/online/Descent3 Online.d3c"
+  "${CMAKE_SOURCE_DIR}/netcon/descent3onlineclient/d3online.d3c.txt"
+  "${CMAKE_SOURCE_DIR}/scripts/data/fullhog/"
+  "$<TARGET_FILE_DIR:Descent3_Online_TCP_IP>"
+  DEPENDS Descent3_Online_TCP_IP HogMaker
+  COMMENT "Generate 'Direct Descent3 Online.d3c'"
 )
 
 install(
diff --git a/netcon/lanclient/CMakeLists.txt b/netcon/lanclient/CMakeLists.txt
index 1ef045abc..633378d75 100644
--- a/netcon/lanclient/CMakeLists.txt
+++ b/netcon/lanclient/CMakeLists.txt
@@ -19,16 +19,17 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
   set_target_properties(Direct_TCP_IP PROPERTIES SUFFIX ".dylib")
 endif()
 
-include(HogMaker)
-MakeHog(
-  TARGET Direct_TCP_IP_Hog
-  OUTPUT "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/online/Direct TCP~IP.d3c"
-  INPUT_FILE "${CMAKE_SOURCE_DIR}/netcon/lanclient/TCP_IP.d3c.txt"
-  SEARCH_PATH "$<TARGET_FILE_DIR:Direct_TCP_IP>" "${CMAKE_SOURCE_DIR}/scripts/data/fullhog/"
-  DEPENDS Direct_TCP_IP
+add_custom_target(Direct_TCP_IP_Hog
+  COMMAND ${HogMakerBin}
+  "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/online/Direct TCP~IP.d3c"
+  "${CMAKE_SOURCE_DIR}/netcon/lanclient/TCP_IP.d3c.txt"
+  "${CMAKE_SOURCE_DIR}/scripts/data/fullhog/"
+  "$<TARGET_FILE_DIR:Direct_TCP_IP>"
+  DEPENDS Direct_TCP_IP HogMaker
+  COMMENT "Generate 'Direct TCP~IP.d3c'"
 )
 
 install(
-  FILES "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/online/Direct TCP~IP.d3c"
-  DESTINATION ${CMAKE_INSTALL_DATADIR}/online
+        FILES "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/online/Direct TCP~IP.d3c"
+        DESTINATION ${CMAKE_INSTALL_DATADIR}/online
 )
diff --git a/netcon/mtclient/CMakeLists.txt b/netcon/mtclient/CMakeLists.txt
index 98e64e320..f99f988e1 100644
--- a/netcon/mtclient/CMakeLists.txt
+++ b/netcon/mtclient/CMakeLists.txt
@@ -29,16 +29,17 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
   set_target_properties(Parallax_Online PROPERTIES SUFFIX ".dylib")
 endif()
 
-include(HogMaker)
-MakeHog(
-  TARGET Parallax_Online_Hog
-  OUTPUT "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/online/Parallax Online.d3c"
-  INPUT_FILE "${CMAKE_SOURCE_DIR}/netcon/mtclient/Parallax_Online.d3c.txt"
-  SEARCH_PATH "$<TARGET_FILE_DIR:Parallax_Online>" "${CMAKE_SOURCE_DIR}/scripts/data/fullhog/"
-  DEPENDS Parallax_Online
+add_custom_target(Parallax_Online_Hog
+  COMMAND ${HogMakerBin}
+  "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/online/Parallax Online.d3c"
+  "${CMAKE_SOURCE_DIR}/netcon/mtclient/Parallax_Online.d3c.txt"
+  "${CMAKE_SOURCE_DIR}/scripts/data/fullhog/"
+  "$<TARGET_FILE_DIR:Parallax_Online>"
+  DEPENDS Parallax_Online HogMaker
+  COMMENT "Generate 'Parallax Online.d3c'"
 )
 
 install(
-  FILES "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/online/Parallax Online.d3c"
-  DESTINATION ${CMAKE_INSTALL_DATADIR}/online
+        FILES "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/online/Parallax Online.d3c"
+        DESTINATION ${CMAKE_INSTALL_DATADIR}/online
 )
diff --git a/scripts/CMakeLists.txt b/scripts/CMakeLists.txt
index 039a64243..560e3e3b5 100644
--- a/scripts/CMakeLists.txt
+++ b/scripts/CMakeLists.txt
@@ -90,13 +90,13 @@ foreach(SCRIPT ${SCRIPTS})
   endif()
 endforeach()
 
-include(HogMaker)
-MakeHog(
-  TARGET HogFull
-  OUTPUT "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/d3-${HOG_NAME}.hog"
-  INPUT_FILE "${CMAKE_SOURCE_DIR}/scripts/data/fullhog/d3-${HOG_NAME}-fullhog.txt"
-  SEARCH_PATH "$<TARGET_FILE_DIR:AIGame>"
-  DEPENDS ${SCRIPTS}
+add_custom_target(HogFull
+  COMMAND ${HogMakerBin}
+    "${D3_GENERATED_FILES_OUTPUT_DIRECTORY}/d3-${HOG_NAME}.hog"
+    "${CMAKE_SOURCE_DIR}/scripts/data/fullhog/d3-${HOG_NAME}-fullhog.txt"
+    "$<TARGET_FILE_DIR:AIGame>"
+  DEPENDS ${SCRIPTS} HogMaker data/fullhog/d3-${HOG_NAME}-fullhog.txt
+  COMMENT "Generate fullhog/d3-${HOG_NAME}.hog"
 )
 
 install(
@@ -106,7 +106,7 @@ install(
 
 # FIXME: there may be only one d3-linux.hog, need deal with demo somehow.
 #	add_custom_target(HogLinuxDemo
-#		COMMAND $<TARGET_FILE:HogMaker>
+#		COMMAND ${HogMakerBin}
 #     "${CMAKE_BINARY_DIR}/scripts/data/demohog/d3-${HOG_NAME}.hog"
 #     "${CMAKE_BINARY_DIR}/scripts/data/demohog/d3-${HOG_NAME}-demohog.txt"
 #     "${CMAKE_BINARY_DIR}/scripts/"
diff --git a/tools/CMakeLists.txt b/tools/CMakeLists.txt
index 1b34f7e45..84718370d 100644
--- a/tools/CMakeLists.txt
+++ b/tools/CMakeLists.txt
@@ -1,7 +1,14 @@
+cmake_minimum_required(VERSION 3.20)  # For using CMAKE_<LANG>_BYTE_ORDER
+
+project(HogMaker LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
 add_executable(
 	HogMaker
 	HogMaker/HogFormat.cpp
 	HogMaker/HogMaker.cpp
 )
-target_include_directories(HogMaker PRIVATE ${PROJECT_BINARY_DIR}/lib)
-export(TARGETS HogMaker FILE "${CMAKE_BINARY_DIR}/HogMakerConfig.cmake")
\ No newline at end of file
+
+target_include_directories(HogMaker PRIVATE ${PROJECT_SOURCE_DIR}/../lib ${PROJECT_BINARY_DIR}/lib)

From 7d62278939b4c16f6466107279ea44814836e0bf Mon Sep 17 00:00:00 2001
From: Chris Sarbora <tophyr@gmail.com>
Date: Mon, 30 Dec 2024 00:46:03 -0600
Subject: [PATCH 02/10] Fix printf security hole

---
 linux/lnxcon_null.cpp | 2 +-
 linux/lnxcon_raw.cpp  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/linux/lnxcon_null.cpp b/linux/lnxcon_null.cpp
index c9196260b..3612d3b3c 100644
--- a/linux/lnxcon_null.cpp
+++ b/linux/lnxcon_null.cpp
@@ -70,4 +70,4 @@ bool con_null_Create() {
 void con_null_Destroy() {}
 
 // put some data up on the screen
-void con_null_Puts(int window, const char *str) { mprintf(0, str); }
+void con_null_Puts(int window, const char *str) { mprintf(0, "%s", str); }
diff --git a/linux/lnxcon_raw.cpp b/linux/lnxcon_raw.cpp
index f205d01c6..3cac8f407 100644
--- a/linux/lnxcon_raw.cpp
+++ b/linux/lnxcon_raw.cpp
@@ -174,6 +174,6 @@ void con_raw_Destroy() {
 
 // put some data up on the screen
 void con_raw_Puts(int window, const char *str) {
-  fprintf(stdout, str);
+  fprintf(stdout, "%s", str);
   fflush(stdout);
 }

From 1d18b2531cc614ebd0a77545b9e0a0c386ea3abe Mon Sep 17 00:00:00 2001
From: Chris Sarbora <tophyr@gmail.com>
Date: Fri, 21 Jun 2024 18:40:19 -0500
Subject: [PATCH 03/10] Add top-level Android compile definitions, based on
 Linux

NOTE: __LINUX__ not defined in top-level definitions, because SDL will just undef it anyway
---
 CMakeLists.txt        |  4 ++++
 ddebug/CMakeLists.txt |  2 +-
 ddio/CMakeLists.txt   |  2 +-
 ddio/lnxio.cpp        |  2 +-
 linux/lnxapp.cpp      | 12 ++++++------
 module/module.h       |  2 +-
 6 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 7b7cf444d..31d114f35 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -170,6 +170,10 @@ elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
   message("Building for MAC OSX")
   add_compile_definitions(POSIX MACOSX=1 _USE_OGL_ACTIVE_TEXTURES PRIMARY_HOG=\"d3-osx.hog\")
   set(PLATFORM_INCLUDES "lib/linux" ${SDL2_INCLUDE_DIR} ${SDL2_INCLUDE_DIRS})
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Android")
+  message("Building for Android")
+  add_compile_definitions(POSIX ANDROID _USE_OGL_ACTIVE_TEXTURES PRIMARY_HOG=\"d3-android.hog\")
+  set(PLATFORM_INCLUDES "lib/linux" ${SDL2_INCLUDE_DIR} ${SDL2_INCLUDE_DIRS})
 elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
   # Windows.h defines to avoid as many issues as possible.
   add_compile_definitions(WIN32_LEAN_AND_MEAN NOMINMAX NODRAWTEXT NOBITMAP NOMCX NOSERVICE PRIMARY_HOG=\"d3-win.hog\"
diff --git a/ddebug/CMakeLists.txt b/ddebug/CMakeLists.txt
index 8d4aec7d6..7e01f6006 100644
--- a/ddebug/CMakeLists.txt
+++ b/ddebug/CMakeLists.txt
@@ -6,7 +6,7 @@ set(HEADERS
 set(CPPS
   debug.cpp
   error.cpp
-  $<$<PLATFORM_ID:Darwin,Linux,OpenBSD>:
+  $<$<PLATFORM_ID:Darwin,Linux,OpenBSD,Android>:
     lnxdebug.cpp
     lnxmono.cpp
   >
diff --git a/ddio/CMakeLists.txt b/ddio/CMakeLists.txt
index b2f7d4468..c10c863c0 100644
--- a/ddio/CMakeLists.txt
+++ b/ddio/CMakeLists.txt
@@ -19,7 +19,7 @@ set(CPPS
   lnxmouse.cpp
   lnxkey_sdl.cpp
   sdlcontroller.cpp
-  $<$<PLATFORM_ID:Darwin,Linux,OpenBSD>:
+  $<$<PLATFORM_ID:Darwin,Linux,OpenBSD,Android>:
     lnxfile.cpp
   >
   $<$<PLATFORM_ID:Windows>:
diff --git a/ddio/lnxio.cpp b/ddio/lnxio.cpp
index c96173b2b..0a1d16824 100644
--- a/ddio/lnxio.cpp
+++ b/ddio/lnxio.cpp
@@ -118,7 +118,7 @@ bool ddio_GetBinaryPath(char *exec_path, size_t len) {
     LOG_ERROR.printf("Buffer too small; need size %u", size);
     return false;
   }
-#elif defined(__LINUX__)
+#elif defined(__LINUX__) || defined(ANDROID)
   if (realpath("/proc/self/exe", exec_path) == NULL) {
    perror("realpath");
    return false;
diff --git a/linux/lnxapp.cpp b/linux/lnxapp.cpp
index bd6ceed89..379b1aa58 100644
--- a/linux/lnxapp.cpp
+++ b/linux/lnxapp.cpp
@@ -69,9 +69,9 @@
  */
 
 #include <cstdlib>
-#if defined(POSIX)
+#if defined(POSIX) && !defined(ANDROID)
 #include <termios.h>
-#else
+#elif defined(WIN32)
 #include "winsock.h"
 #endif
 
@@ -83,7 +83,7 @@
 #undef buttons
 #endif
 
-#if defined(POSIX)
+#if defined(POSIX) && !defined(ANDROID)
 static struct termios Linux_initial_terminal_settings;
 #endif
 
@@ -105,7 +105,7 @@ void LnxAppShutdown() {
   LinuxAppDontCallShutdown = true;
   if (LinuxAppFlags & OEAPP_CONSOLE) {
     con_Destroy();
-#if defined(POSIX)
+#if defined(POSIX) && !defined(ANDROID)
     tcsetattr(0, TCSANOW, &Linux_initial_terminal_settings);
 #endif
   }
@@ -117,7 +117,7 @@ oeLnxApplication::oeLnxApplication(unsigned flags) {
   m_AppActive = true;
 
   if (flags & OEAPP_CONSOLE) {
-#if defined(POSIX)
+#if defined(POSIX) && !defined(ANDROID)
     tcgetattr(0, &Linux_initial_terminal_settings);
 #endif
     con_Create(m_Flags);
@@ -133,7 +133,7 @@ oeLnxApplication::oeLnxApplication(unsigned flags) {
 
 //	Create object with a premade info
 oeLnxApplication::oeLnxApplication(tLnxAppInfo *appinfo) {
-#if defined(POSIX)
+#if defined(POSIX) && !defined(ANDROID)
   tcgetattr(0, &Linux_initial_terminal_settings);
 #endif
   m_Flags = appinfo->flags;
diff --git a/module/module.h b/module/module.h
index a625754c8..e8e4b7b24 100644
--- a/module/module.h
+++ b/module/module.h
@@ -97,7 +97,7 @@
 // Platform-specific library extensions
 #if defined(WIN32)
 #define MODULE_EXT ".dll"
-#elif defined(__LINUX__)
+#elif defined(__LINUX__) || defined(ANDROID)
 #define MODULE_EXT ".so"
 #elif defined(MACOSX)
 #define MODULE_EXT ".dylib"

From 4a8730aa9ed8ebbc4d02ff3c2bf83318ac2469cf Mon Sep 17 00:00:00 2001
From: Chris Sarbora <tophyr@gmail.com>
Date: Fri, 21 Jun 2024 20:20:32 -0500
Subject: [PATCH 04/10] Generate a d3-android-fullhog

---
 CMakeLists.txt                              |   2 +
 scripts/CMakeLists.txt                      |   2 +-
 scripts/data/fullhog/d3-android-fullhog.txt | 112 ++++++++++++++++++++
 3 files changed, 115 insertions(+), 1 deletion(-)
 create mode 100644 scripts/data/fullhog/d3-android-fullhog.txt

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 31d114f35..cf3c4bbbe 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -128,6 +128,8 @@ elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
   set(HOG_NAME "osx")
 elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
   set(HOG_NAME "win")
+elseif(CMAKE_SYSTEM_NAME STREQUAL "Android")
+  set(HOG_NAME "android")
 endif()
 
 # rebuild d3_version.h every time
diff --git a/scripts/CMakeLists.txt b/scripts/CMakeLists.txt
index 560e3e3b5..f8c0bc57e 100644
--- a/scripts/CMakeLists.txt
+++ b/scripts/CMakeLists.txt
@@ -7,7 +7,7 @@ set(HEADERS
   osiris_import.h
   osiris_vector.h)
 set(CPPS
-  $<$<PLATFORM_ID:Darwin,Linux,OpenBSD>:
+  $<$<PLATFORM_ID:Darwin,Linux,OpenBSD,Android>:
     linux_lib.cpp
   >
 )
diff --git a/scripts/data/fullhog/d3-android-fullhog.txt b/scripts/data/fullhog/d3-android-fullhog.txt
new file mode 100644
index 000000000..4aaac42f3
--- /dev/null
+++ b/scripts/data/fullhog/d3-android-fullhog.txt
@@ -0,0 +1,112 @@
+AIGAMEi.STR
+Anarchy.str
+Anarchyi.str
+CTF.str
+CTFi.str
+D3.STR
+DMFC.str
+DMFCi.str
+GENERIC.STR
+Hyper.str
+LEVEL4i.STR
+LEVELS1i.STR
+LEVELS2i.STR
+Level10i.str
+Level11i.str
+Level12i.str
+Level13i.str
+Level14i.str
+Level15i.str
+Level1i.str
+Level2i.str
+Level3i.str
+Level5i.str
+Level6i.str
+Level7i.str
+Level8i.str
+Level9i.str
+TrainingMissioni.STR
+aigame.str
+coop.str
+coopi.str
+d3i.str
+dp_modem.str
+dp_modemi.str
+dp_serial.str
+dp_seriali.str
+entropy.str
+entropyi.str
+generici.str
+hoard.str
+hoardi.str
+hyperi.str
+ipxclient.str
+ipxclienti.str
+lanclient.str
+lanclienti.str
+monster.str
+monsteri.str
+mtclient.str
+mtclienti.str
+tanarchy.str
+tanarchyi.str
+LEVELS2.str
+pxomain.ogf
+pxogame.ogf
+gamecredits.txt
+loki.ogf
+aigame2.so
+AIGame3.so
+aigame4.so
+AIGame.so
+barney.so
+BatteriesIncluded.so
+BossCamera.so
+CanyonsCTF.so
+CellTestLevel.so
+ChrisTest.so
+clutter.so
+generic.so
+Geodomes.so
+HalfPipe.so
+InfernalBolt.so
+Inversion.so
+LEVEL0.so
+level10.so
+level11.so
+Level12.so
+level13.so
+level14.so
+LEVEL15.so
+Level16.so
+level17.so
+level1.so
+level2.so
+level3.so
+level4.so
+level5.so
+Level6.so
+level7.so
+level8.so
+Level9.so
+LevelS1.so
+levelS2.so
+Merc02.so
+Merc1.so
+Merc3.so
+Merc4.so
+merc5.so
+Merc6.so
+Merc7.so
+myPowerHouse.so
+Mysterious_Isle.so
+orbital.so
+Paranoia.so
+PiccuStation.so
+Polaris.so
+Quadsomniac.so
+RudeAwakening.so
+SewerRat.so
+testscript.so
+TrainingMission.so
+Y2K.so

From 2e38c6dc7c4511b14257bb6dabf00d480db18b0a Mon Sep 17 00:00:00 2001
From: Chris Sarbora <tophyr@gmail.com>
Date: Sat, 22 Jun 2024 21:31:31 -0500
Subject: [PATCH 05/10] Produce a module instead of an executable for Android

---
 Descent3/CMakeLists.txt | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/Descent3/CMakeLists.txt b/Descent3/CMakeLists.txt
index 838e15918..70555b93a 100644
--- a/Descent3/CMakeLists.txt
+++ b/Descent3/CMakeLists.txt
@@ -310,7 +310,13 @@ endif()
 
 file(GLOB_RECURSE INCS "../lib/*.h")
 
-add_executable(Descent3 WIN32 MACOSX_BUNDLE ${D3Icon} ${HEADERS} ${CPPS} ${INCS} ${MANIFEST} ${RC_FILE})
+if(ANDROID)
+  add_library(Descent3 MODULE ${HEADERS} ${CPPS} ${INCS}
+  )
+else()
+  add_executable(Descent3 WIN32 MACOSX_BUNDLE ${D3Icon} ${HEADERS} ${CPPS} ${INCS} ${MANIFEST} ${RC_FILE})
+  install(TARGETS Descent3 RUNTIME BUNDLE DESTINATION .)
+endif()
 target_link_libraries(Descent3 PRIVATE
   SDL2::SDL2
   2dlib
@@ -362,7 +368,6 @@ add_dependencies(Descent3
   tanarchy
 )
 
-install(TARGETS Descent3 RUNTIME BUNDLE DESTINATION .)
 if(MSVC)
   install(FILES $<TARGET_PDB_FILE:Descent3> DESTINATION ${CMAKE_INSTALL_BINDIR})
 endif()

From 23d50805be7a84b8aca521e59ca0e5544c71dad2 Mon Sep 17 00:00:00 2001
From: Chris Sarbora <tophyr@gmail.com>
Date: Mon, 12 Aug 2024 16:22:20 -0500
Subject: [PATCH 06/10] Support both GLES 3.0 and GL 3.2

---
 renderer/CMakeLists.txt                |  2 ++
 renderer/HardwareOpenGL.cpp            | 16 ++++++++++++++--
 renderer/shaders/fragment.glsl         |  8 +++++---
 renderer/shaders/version_150_core.glsl |  1 +
 renderer/shaders/version_300_es.glsl   |  1 +
 renderer/shaders/vertex.glsl           |  2 +-
 6 files changed, 24 insertions(+), 6 deletions(-)
 create mode 100644 renderer/shaders/version_150_core.glsl
 create mode 100644 renderer/shaders/version_300_es.glsl

diff --git a/renderer/CMakeLists.txt b/renderer/CMakeLists.txt
index 51faa986a..9dc4d6b8c 100644
--- a/renderer/CMakeLists.txt
+++ b/renderer/CMakeLists.txt
@@ -3,6 +3,8 @@ cmake_path(SET SHADERS_H NORMALIZE ${GENERATED_HEADERS}/shaders.h)
 set(SHADERS
   shaders/fragment.glsl
   shaders/vertex.glsl
+  shaders/version_300_es.glsl
+  shaders/version_150_core.glsl
 )
 add_custom_command(
   OUTPUT ${SHADERS_H}
diff --git a/renderer/HardwareOpenGL.cpp b/renderer/HardwareOpenGL.cpp
index 40f48f027..d5c690539 100644
--- a/renderer/HardwareOpenGL.cpp
+++ b/renderer/HardwareOpenGL.cpp
@@ -66,12 +66,15 @@ extern uint8_t Renderer_initted;
 renderer_type Renderer_type = RENDERER_OPENGL;
 
 struct Renderer {
-  Renderer() : shader_{shaders::vertex, shaders::fragment, {
+  Renderer() : shader_{
+    std::string{kGlslVersion} + std::string{shaders::vertex},
+    std::string{kGlslVersion} + std::string{shaders::fragment},
+    {
       vertexAttrib(3, GL_FLOAT, GL_FALSE, &PosColorUV2Vertex::pos, "in_pos"),
       vertexAttrib(4, GL_FLOAT, GL_FALSE, &PosColorUV2Vertex::color, "in_color"),
       vertexAttrib(2, GL_FLOAT, GL_FALSE, &PosColorUV2Vertex::uv0, "in_uv0"),
       vertexAttrib(2, GL_FLOAT, GL_FALSE, &PosColorUV2Vertex::uv1, "in_uv1")
-  }} {
+    }} {
     shader_.Use();
 
     // these are effectively just constants, for now
@@ -146,6 +149,13 @@ struct Renderer {
   glm::mat4x4 projection_;
   GLint texture_enable_{};
   ShaderProgram<PosColorUV2Vertex> shader_;
+
+  static constexpr auto kGlslVersion =
+#if defined(ANDROID)
+      shaders::version_300_es;
+#else
+  shaders::version_150_core;
+#endif
 };
 std::optional<Renderer> gRenderer;
 
@@ -415,8 +425,10 @@ int opengl_Setup(oeApplication *app, const int *width, const int *height) {
   SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
   SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+#if !defined(ANDROID)
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
   SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
+#endif
   Uint32 flags = SDL_WINDOW_OPENGL;
 
   if (fullscreen) {
diff --git a/renderer/shaders/fragment.glsl b/renderer/shaders/fragment.glsl
index a39be0b94..2ea9e1e00 100644
--- a/renderer/shaders/fragment.glsl
+++ b/renderer/shaders/fragment.glsl
@@ -1,4 +1,4 @@
-#version 150 core
+// version must be prepended to this file
 
 /*
 * Descent 3
@@ -18,6 +18,8 @@
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
+precision highp float;
+
 in vec4 vertex_color;
 in vec2 vertex_uv0;
 in vec2 vertex_uv1;
@@ -50,9 +52,9 @@ void main()
         * max(texture(u_texture0, vertex_uv0), vec4(float(!bool((u_texture_enable >> 0) & 1))))
         * max(texture(u_texture1, vertex_uv1), vec4(float(!bool((u_texture_enable >> 1) & 1))));
 
-    float fog_factor = clamp((u_fog_end - length(vertex_modelview_pos)) * branchless_invert_or_zero(u_fog_end - u_fog_start), 0, 1);
+    float fog_factor = clamp((u_fog_end - length(vertex_modelview_pos)) * branchless_invert_or_zero(u_fog_end - u_fog_start), 0.0, 1.0);
     // out_color is unchanged when fog_factor is 1 (ie, fog distance == u_fog_start). thus, to disable,
     // fog_factor must also be 1. invert u_fog_enable (so that it is 1 when disabled) and take the max.
     fog_factor = max(fog_factor, float(!u_fog_enable));
-    out_color = out_color * fog_factor + (1 - fog_factor) * u_fog_color;
+    out_color = out_color * fog_factor + (1.0 - fog_factor) * u_fog_color;
 }
\ No newline at end of file
diff --git a/renderer/shaders/version_150_core.glsl b/renderer/shaders/version_150_core.glsl
new file mode 100644
index 000000000..6907ee2ea
--- /dev/null
+++ b/renderer/shaders/version_150_core.glsl
@@ -0,0 +1 @@
+#version 150 core
\ No newline at end of file
diff --git a/renderer/shaders/version_300_es.glsl b/renderer/shaders/version_300_es.glsl
new file mode 100644
index 000000000..03e7b1e84
--- /dev/null
+++ b/renderer/shaders/version_300_es.glsl
@@ -0,0 +1 @@
+#version 300 es
\ No newline at end of file
diff --git a/renderer/shaders/vertex.glsl b/renderer/shaders/vertex.glsl
index 119097663..5ab48b0f9 100644
--- a/renderer/shaders/vertex.glsl
+++ b/renderer/shaders/vertex.glsl
@@ -1,4 +1,4 @@
-#version 150 core
+// version must be prepended to this file
 
 /*
 * Descent 3

From 0b82fff245c70dd99fbafaccc6ac491f0df76707 Mon Sep 17 00:00:00 2001
From: Chris Sarbora <tophyr@gmail.com>
Date: Sun, 23 Jun 2024 23:15:50 -0500
Subject: [PATCH 07/10] Add Android support

---
 .github/workflows/build.yml                   |    18 +-
 .gitignore                                    |     7 +
 CMakeLists.txt                                |    16 +
 android/build.gradle                          |    52 +
 android/proguard-rules.pro                    |    17 +
 android/src/main/AndroidManifest.xml          |    93 +
 android/src/main/assets/css/style.css         |    10 +
 .../src/main/assets/errors/400_no_d3hog.html  |     7 +
 android/src/main/assets/errors/404.html       |     6 +
 android/src/main/assets/errors/405.html       |     6 +
 android/src/main/assets/errors/501.html       |     6 +
 android/src/main/assets/index.html            |    16 +
 android/src/main/assets/js/jquery-3.7.1.js    | 10716 ++++++++++++++++
 android/src/main/assets/js/main.js            |     0
 android/src/main/assets/success.html          |    11 +
 .../droid/GameDataUploadActivity.java         |   219 +
 .../java/com/descent3/droid/MainActivity.java |    57 +
 .../main/java/org/libsdl/app/HIDDevice.java   |    35 +
 .../app/HIDDeviceBLESteamController.java      |   638 +
 .../java/org/libsdl/app/HIDDeviceManager.java |   696 +
 .../java/org/libsdl/app/HIDDeviceUSB.java     |   310 +
 android/src/main/java/org/libsdl/app/SDL.java |    86 +
 .../main/java/org/libsdl/app/SDLActivity.java |  2127 +++
 .../java/org/libsdl/app/SDLAudioManager.java  |   521 +
 .../org/libsdl/app/SDLControllerManager.java  |   863 ++
 .../main/java/org/libsdl/app/SDLSurface.java  |   401 +
 .../res/layout/game_data_layout_activity.xml  |    12 +
 .../main/res/mipmap-xxxhdpi/ic_launcher.webp  |   Bin 0 -> 2020 bytes
 android/src/main/res/values/colors.xml        |     6 +
 android/src/main/res/values/strings.xml       |     3 +
 android/src/main/res/values/styles.xml        |     7 +
 build.gradle                                  |    25 +
 gradle.properties                             |    17 +
 gradle/wrapper/gradle-wrapper.jar             |   Bin 0 -> 54213 bytes
 gradle/wrapper/gradle-wrapper.properties      |     6 +
 gradlew                                       |   160 +
 gradlew.bat                                   |    90 +
 settings.gradle                               |     1 +
 38 files changed, 17260 insertions(+), 1 deletion(-)
 create mode 100644 android/build.gradle
 create mode 100644 android/proguard-rules.pro
 create mode 100644 android/src/main/AndroidManifest.xml
 create mode 100644 android/src/main/assets/css/style.css
 create mode 100644 android/src/main/assets/errors/400_no_d3hog.html
 create mode 100644 android/src/main/assets/errors/404.html
 create mode 100644 android/src/main/assets/errors/405.html
 create mode 100644 android/src/main/assets/errors/501.html
 create mode 100644 android/src/main/assets/index.html
 create mode 100644 android/src/main/assets/js/jquery-3.7.1.js
 create mode 100644 android/src/main/assets/js/main.js
 create mode 100644 android/src/main/assets/success.html
 create mode 100644 android/src/main/java/com/descent3/droid/GameDataUploadActivity.java
 create mode 100644 android/src/main/java/com/descent3/droid/MainActivity.java
 create mode 100644 android/src/main/java/org/libsdl/app/HIDDevice.java
 create mode 100644 android/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java
 create mode 100644 android/src/main/java/org/libsdl/app/HIDDeviceManager.java
 create mode 100644 android/src/main/java/org/libsdl/app/HIDDeviceUSB.java
 create mode 100644 android/src/main/java/org/libsdl/app/SDL.java
 create mode 100644 android/src/main/java/org/libsdl/app/SDLActivity.java
 create mode 100644 android/src/main/java/org/libsdl/app/SDLAudioManager.java
 create mode 100644 android/src/main/java/org/libsdl/app/SDLControllerManager.java
 create mode 100644 android/src/main/java/org/libsdl/app/SDLSurface.java
 create mode 100644 android/src/main/res/layout/game_data_layout_activity.xml
 create mode 100644 android/src/main/res/mipmap-xxxhdpi/ic_launcher.webp
 create mode 100644 android/src/main/res/values/colors.xml
 create mode 100644 android/src/main/res/values/strings.xml
 create mode 100644 android/src/main/res/values/styles.xml
 create mode 100644 build.gradle
 create mode 100644 gradle.properties
 create mode 100644 gradle/wrapper/gradle-wrapper.jar
 create mode 100644 gradle/wrapper/gradle-wrapper.properties
 create mode 100755 gradlew
 create mode 100644 gradlew.bat
 create mode 100644 settings.gradle

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index fbda3294f..0a68f5afa 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -47,6 +47,8 @@ jobs:
           - runner: ubuntu-latest
             preset: linux-cross-arm64
             name: Linux-cross-arm64
+          - runner: ubuntu-latest
+            name: android
         build_type:
           - Debug
           - Release
@@ -100,24 +102,38 @@ jobs:
         with:
           vcpkgJsonGlob: vcpkg.json
 
+      - uses: actions/setup-java@v4
+        if: ${{ matrix.os.name == 'android' }}
+        with:
+         java-version: '17'
+         distribution: 'temurin'
+
+      - name: Build APK
+        if: ${{ matrix.os.name == 'android' }}
+        run: ./gradlew build
+
       - name: Configure CMake
+        if: ${{ matrix.os.name != 'android' }}
         env:
           CC: ${{ matrix.os.cc }}
           CXX: ${{ matrix.os.cxx }}
         run: cmake --preset ${{ matrix.os.preset }} -DENABLE_LOGGER=ON -DFORCE_PORTABLE_INSTALL=ON -DUSE_EXTERNAL_PLOG=ON -DBUILD_EDITOR=ON -DBUILD_TESTING=${{ matrix.os.preset == 'linux-cross-arm64' && 'OFF' || 'ON' }}
 
       - name: Build ${{ matrix.build_type }}
+        if: ${{ matrix.os.name != 'android' }}
         run: cmake --build --preset ${{ matrix.os.preset }} --config ${{ matrix.build_type }} --verbose
 
       - name: Run ${{ matrix.build_type }} Unittests
-        if: ${{ matrix.os.preset != 'linux-cross-arm64' }}
+        if: ${{ matrix.os.preset != 'linux-cross-arm64' && matrix.os.name != 'android' }}
         run: ctest --preset ${{ matrix.os.preset }} -C ${{ matrix.build_type }}
 
       - name: Local install
+        if: ${{ matrix.os.name != 'android' }}
         # There no cmake install presets so install in traditional way
         run: cmake --install builds/${{ matrix.os.preset }}/ --config ${{ matrix.build_type }}
 
       - name: Upload Artifacts
+        if: ${{ matrix.os.name != 'android' }}
         uses: actions/upload-artifact@v4
         with:
           name: Descent3_${{ matrix.build_type }}_${{ matrix.os.name }}
diff --git a/.gitignore b/.gitignore
index ca87a68c1..5ec178592 100644
--- a/.gitignore
+++ b/.gitignore
@@ -408,3 +408,10 @@ build[s]
 
 # Ignore autogenerated git-hash.txt file, generated for packaging purposes
 git-hash.txt
+
+# Android build bits
+.gradle/*
+android/.cxx/*
+android/build/*
+build/*
+local.properties
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cf3c4bbbe..a00195b6b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,6 +9,22 @@ endif()
 set(USE_VCPKG "DEFAULT" CACHE STRING "Use vcpkg for dependency management. DEFAULT defers to existence of $VCPKG_ROOT environment variable.")
 set_property(CACHE USE_VCPKG PROPERTY STRINGS "DEFAULT" "ON" "OFF")
 
+if (CMAKE_SYSTEM_NAME STREQUAL "Android")
+  if (ANDROID_ABI MATCHES "arm64-v8a")
+    set(VCPKG_TARGET_TRIPLET "arm64-android" CACHE STRING "" FORCE)
+  elseif(ANDROID_ABI MATCHES "armeabi-v7a")
+    set(VCPKG_TARGET_TRIPLET "arm-android" CACHE STRING "" FORCE)
+  elseif(ANDROID_ABI MATCHES "x86_64")
+    set(VCPKG_TARGET_TRIPLET "x64-android" CACHE STRING "" FORCE)
+  elseif(ANDROID_ABI MATCHES "x86")
+    set(VCPKG_TARGET_TRIPLET "x86-android" CACHE STRING "" FORCE)
+  else()
+    message(FATAL_ERROR "ANDROID_ABI not set or not recognized")
+  endif()
+
+  set(ENV{ANDROID_NDK_HOME} ${CMAKE_ANDROID_NDK})
+endif()
+
 if(USE_VCPKG)
   if(DEFINED ENV{VCPKG_ROOT})
     if (CMAKE_TOOLCHAIN_FILE)
diff --git a/android/build.gradle b/android/build.gradle
new file mode 100644
index 000000000..c41f02242
--- /dev/null
+++ b/android/build.gradle
@@ -0,0 +1,52 @@
+apply plugin: 'com.android.application'
+
+repositories {
+  mavenCentral()
+}
+
+android {
+    namespace "com.descent3.droid"
+    compileSdk 34
+    defaultConfig {
+        minSdkVersion 32
+        targetSdkVersion 34
+        versionCode 1
+        versionName "1.0"
+        externalNativeBuild {
+            cmake {
+                arguments "-DANDROID_APP_PLATFORM=android-19", "-DANDROID_STL=c++_static", "-DENABLE_LOGGER=ON"
+                // abiFilters 'armeabi-v7a', 'arm64-v8a', 'x86', 'x86_64'
+                abiFilters 'arm64-v8a'
+            }
+        }
+    }
+    buildTypes {
+        release {
+            minifyEnabled false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    applicationVariants.all { variant ->
+        tasks["merge${variant.name.capitalize()}Assets"]
+            .dependsOn("externalNativeBuild${variant.name.capitalize()}")
+    }
+    sourceSets {
+        main {
+            jniLibs.srcDir 'libs'
+            java.srcDirs = ['src/main/java']
+        }
+    }
+    externalNativeBuild {
+        cmake {
+            path '../CMakeLists.txt'
+        }
+    }
+    lint {
+        abortOnError false
+    }
+}
+
+dependencies {
+  implementation fileTree(include: ['*.jar'], dir: 'libs')
+  implementation 'org.nanohttpd:nanohttpd:2.2.0'
+}
diff --git a/android/proguard-rules.pro b/android/proguard-rules.pro
new file mode 100644
index 000000000..eaf0e916c
--- /dev/null
+++ b/android/proguard-rules.pro
@@ -0,0 +1,17 @@
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in [sdk]/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
diff --git a/android/src/main/AndroidManifest.xml b/android/src/main/AndroidManifest.xml
new file mode 100644
index 000000000..3ca93d8ab
--- /dev/null
+++ b/android/src/main/AndroidManifest.xml
@@ -0,0 +1,93 @@
+<?xml version="1.0" encoding="utf-8"?><!-- Replace com.test.game with the identifier of your game below, e.g.
+     com.gamemaker.game
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  android:installLocation="auto"
+  android:versionCode="1"
+  android:versionName="devel">
+
+  <!-- OpenGL ES 3.2 -->
+  <uses-feature
+    android:glEsVersion="0x00030002"
+    android:required="true" />
+
+  <!-- Touchscreen support -->
+  <uses-feature
+    android:name="android.hardware.touchscreen"
+    android:required="false" />
+
+  <!-- Game controller support -->
+  <uses-feature
+    android:name="android.hardware.bluetooth"
+    android:required="false" />
+  <uses-feature
+    android:name="android.hardware.gamepad"
+    android:required="false" />
+  <uses-feature
+    android:name="android.hardware.usb.host"
+    android:required="false" />
+
+  <!-- External mouse input events -->
+  <uses-feature
+    android:name="android.hardware.type.pc"
+    android:required="false" />
+
+  <!-- Audio recording support -->
+  <!-- if you want to capture audio, uncomment this. -->
+  <!-- <uses-feature
+      android:name="android.hardware.microphone"
+      android:required="false" /> -->
+  <!-- <uses-permission android:name="android.permission.RECORD_AUDIO" /> -->
+
+  <!-- Allow access to Bluetooth devices -->
+  <!-- Currently this is just for Steam Controller support and requires setting SDL_HINT_JOYSTICK_HIDAPI_STEAM -->
+  <!-- <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" /> -->
+  <!-- <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" /> -->
+
+  <!-- Allow access to the vibrator -->
+  <uses-permission android:name="android.permission.VIBRATE" />
+  <uses-permission android:name="android.permission.INTERNET" />
+
+  <!-- Create a Java class extending SDLActivity and place it in a
+       directory under app/src/main/java matching the package, e.g. app/src/main/java/com/gamemaker/game/MyGame.java
+
+       then replace "SDLActivity" with the name of your class (e.g. "MyGame")
+       in the XML below.
+
+       An example Java class can be found in README-android.md
+  -->
+  <application
+    android:allowBackup="true"
+    android:hardwareAccelerated="true"
+    android:icon="@mipmap/ic_launcher"
+    android:label="@string/app_name"
+    android:theme="@style/AppTheme">
+
+    <!-- Example of setting SDL hints from AndroidManifest.xml:
+    <meta-data android:name="SDL_ENV.SDL_ACCELEROMETER_AS_JOYSTICK" android:value="0"/>
+     -->
+
+    <activity
+      android:name="MainActivity"
+      android:alwaysRetainTaskState="true"
+      android:configChanges="layoutDirection|locale|orientation|uiMode|screenLayout|screenSize|smallestScreenSize|keyboard|keyboardHidden|navigation"
+      android:exported="true"
+      android:label="@string/app_name"
+      android:launchMode="singleInstance"
+      android:preferMinimalPostProcessing="true">
+
+      <!-- Let Android know that we can handle some USB devices and should receive this event -->
+      <intent-filter>
+        <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />
+      </intent-filter>
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+    </activity>
+    <activity
+      android:name="com.descent3.droid.GameDataUploadActivity"
+      android:exported="true" />
+  </application>
+
+</manifest>
diff --git a/android/src/main/assets/css/style.css b/android/src/main/assets/css/style.css
new file mode 100644
index 000000000..d7b470c6a
--- /dev/null
+++ b/android/src/main/assets/css/style.css
@@ -0,0 +1,10 @@
+.title {
+  font-size: 24pt;
+  text-align: center;
+}
+.dir_select {
+  margin: 12pt;
+  border: 2pt solid black;
+  padding: 12pt;
+  text-align: center;
+}
\ No newline at end of file
diff --git a/android/src/main/assets/errors/400_no_d3hog.html b/android/src/main/assets/errors/400_no_d3hog.html
new file mode 100644
index 000000000..ba04ed2f7
--- /dev/null
+++ b/android/src/main/assets/errors/400_no_d3hog.html
@@ -0,0 +1,7 @@
+<html>
+<head><title>Not Found</title></head>
+<body>
+<h1 style="text-align: center;">Bad Request</h1>
+<h3 style="text-align: center;">d3.hog not found in upload</h3>
+</body>
+</html>
\ No newline at end of file
diff --git a/android/src/main/assets/errors/404.html b/android/src/main/assets/errors/404.html
new file mode 100644
index 000000000..147399f32
--- /dev/null
+++ b/android/src/main/assets/errors/404.html
@@ -0,0 +1,6 @@
+<html>
+<head><title>Not Found</title></head>
+<body>
+<h1 style="text-align: center;">Not Found</h1>
+</body>
+</html>
\ No newline at end of file
diff --git a/android/src/main/assets/errors/405.html b/android/src/main/assets/errors/405.html
new file mode 100644
index 000000000..bc8ae6932
--- /dev/null
+++ b/android/src/main/assets/errors/405.html
@@ -0,0 +1,6 @@
+<html>
+<head><title>Method Not Allowed</title></head>
+<body>
+<h1 style="text-align: center;">Method Not Allowed</h1>
+</body>
+</html>
\ No newline at end of file
diff --git a/android/src/main/assets/errors/501.html b/android/src/main/assets/errors/501.html
new file mode 100644
index 000000000..7cc24e141
--- /dev/null
+++ b/android/src/main/assets/errors/501.html
@@ -0,0 +1,6 @@
+<html>
+<head><title>Not Implemented</title></head>
+<body>
+<h1 style="text-align: center;">Not Implemented</h1>
+</body>
+</html>
\ No newline at end of file
diff --git a/android/src/main/assets/index.html b/android/src/main/assets/index.html
new file mode 100644
index 000000000..881f12d39
--- /dev/null
+++ b/android/src/main/assets/index.html
@@ -0,0 +1,16 @@
+<html>
+<head>
+  <link href="css/style.css" rel="stylesheet"/>
+  <script src="js/jquery-3.7.1.js" type="text/javascript"></script>
+  <script src="js/main.js" type="text/javascript"></script>
+  <title>Upload Game Data</title>
+</head>
+<body>
+<div class="title">Upload Game Data</div>
+<form action="" class="dir_select" enctype="multipart/form-data" method="post">
+  Upload Descent 3 Game Data:
+  <input id="file" mozdirectory name="file" type="file" webkitdirectory/>
+  <input id="submit" type="submit"/>
+</form>
+</body>
+</html>
\ No newline at end of file
diff --git a/android/src/main/assets/js/jquery-3.7.1.js b/android/src/main/assets/js/jquery-3.7.1.js
new file mode 100644
index 000000000..5a1e8cddc
--- /dev/null
+++ b/android/src/main/assets/js/jquery-3.7.1.js
@@ -0,0 +1,10716 @@
+/*!
+ * jQuery JavaScript Library v3.7.1
+ * https://jquery.com/
+ *
+ * Copyright OpenJS Foundation and other contributors
+ * Released under the MIT license
+ * https://jquery.org/license
+ *
+ * Date: 2023-08-28T13:37Z
+ */
+( function( global, factory ) {
+
+	"use strict";
+
+	if ( typeof module === "object" && typeof module.exports === "object" ) {
+
+		// For CommonJS and CommonJS-like environments where a proper `window`
+		// is present, execute the factory and get jQuery.
+		// For environments that do not have a `window` with a `document`
+		// (such as Node.js), expose a factory as module.exports.
+		// This accentuates the need for the creation of a real `window`.
+		// e.g. var jQuery = require("jquery")(window);
+		// See ticket trac-14549 for more info.
+		module.exports = global.document ?
+			factory( global, true ) :
+			function( w ) {
+				if ( !w.document ) {
+					throw new Error( "jQuery requires a window with a document" );
+				}
+				return factory( w );
+			};
+	} else {
+		factory( global );
+	}
+
+// Pass this if window is not defined yet
+} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
+
+// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
+// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
+// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
+// enough that all such attempts are guarded in a try block.
+"use strict";
+
+var arr = [];
+
+var getProto = Object.getPrototypeOf;
+
+var slice = arr.slice;
+
+var flat = arr.flat ? function( array ) {
+	return arr.flat.call( array );
+} : function( array ) {
+	return arr.concat.apply( [], array );
+};
+
+
+var push = arr.push;
+
+var indexOf = arr.indexOf;
+
+var class2type = {};
+
+var toString = class2type.toString;
+
+var hasOwn = class2type.hasOwnProperty;
+
+var fnToString = hasOwn.toString;
+
+var ObjectFunctionString = fnToString.call( Object );
+
+var support = {};
+
+var isFunction = function isFunction( obj ) {
+
+		// Support: Chrome <=57, Firefox <=52
+		// In some browsers, typeof returns "function" for HTML <object> elements
+		// (i.e., `typeof document.createElement( "object" ) === "function"`).
+		// We don't want to classify *any* DOM node as a function.
+		// Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
+		// Plus for old WebKit, typeof returns "function" for HTML collections
+		// (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
+		return typeof obj === "function" && typeof obj.nodeType !== "number" &&
+			typeof obj.item !== "function";
+	};
+
+
+var isWindow = function isWindow( obj ) {
+		return obj != null && obj === obj.window;
+	};
+
+
+var document = window.document;
+
+
+
+	var preservedScriptAttributes = {
+		type: true,
+		src: true,
+		nonce: true,
+		noModule: true
+	};
+
+	function DOMEval( code, node, doc ) {
+		doc = doc || document;
+
+		var i, val,
+			script = doc.createElement( "script" );
+
+		script.text = code;
+		if ( node ) {
+			for ( i in preservedScriptAttributes ) {
+
+				// Support: Firefox 64+, Edge 18+
+				// Some browsers don't support the "nonce" property on scripts.
+				// On the other hand, just using `getAttribute` is not enough as
+				// the `nonce` attribute is reset to an empty string whenever it
+				// becomes browsing-context connected.
+				// See https://github.com/whatwg/html/issues/2369
+				// See https://html.spec.whatwg.org/#nonce-attributes
+				// The `node.getAttribute` check was added for the sake of
+				// `jQuery.globalEval` so that it can fake a nonce-containing node
+				// via an object.
+				val = node[ i ] || node.getAttribute && node.getAttribute( i );
+				if ( val ) {
+					script.setAttribute( i, val );
+				}
+			}
+		}
+		doc.head.appendChild( script ).parentNode.removeChild( script );
+	}
+
+
+function toType( obj ) {
+	if ( obj == null ) {
+		return obj + "";
+	}
+
+	// Support: Android <=2.3 only (functionish RegExp)
+	return typeof obj === "object" || typeof obj === "function" ?
+		class2type[ toString.call( obj ) ] || "object" :
+		typeof obj;
+}
+/* global Symbol */
+// Defining this global in .eslintrc.json would create a danger of using the global
+// unguarded in another place, it seems safer to define global only for this module
+
+
+
+var version = "3.7.1",
+
+	rhtmlSuffix = /HTML$/i,
+
+	// Define a local copy of jQuery
+	jQuery = function( selector, context ) {
+
+		// The jQuery object is actually just the init constructor 'enhanced'
+		// Need init if jQuery is called (just allow error to be thrown if not included)
+		return new jQuery.fn.init( selector, context );
+	};
+
+jQuery.fn = jQuery.prototype = {
+
+	// The current version of jQuery being used
+	jquery: version,
+
+	constructor: jQuery,
+
+	// The default length of a jQuery object is 0
+	length: 0,
+
+	toArray: function() {
+		return slice.call( this );
+	},
+
+	// Get the Nth element in the matched element set OR
+	// Get the whole matched element set as a clean array
+	get: function( num ) {
+
+		// Return all the elements in a clean array
+		if ( num == null ) {
+			return slice.call( this );
+		}
+
+		// Return just the one element from the set
+		return num < 0 ? this[ num + this.length ] : this[ num ];
+	},
+
+	// Take an array of elements and push it onto the stack
+	// (returning the new matched element set)
+	pushStack: function( elems ) {
+
+		// Build a new jQuery matched element set
+		var ret = jQuery.merge( this.constructor(), elems );
+
+		// Add the old object onto the stack (as a reference)
+		ret.prevObject = this;
+
+		// Return the newly-formed element set
+		return ret;
+	},
+
+	// Execute a callback for every element in the matched set.
+	each: function( callback ) {
+		return jQuery.each( this, callback );
+	},
+
+	map: function( callback ) {
+		return this.pushStack( jQuery.map( this, function( elem, i ) {
+			return callback.call( elem, i, elem );
+		} ) );
+	},
+
+	slice: function() {
+		return this.pushStack( slice.apply( this, arguments ) );
+	},
+
+	first: function() {
+		return this.eq( 0 );
+	},
+
+	last: function() {
+		return this.eq( -1 );
+	},
+
+	even: function() {
+		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
+			return ( i + 1 ) % 2;
+		} ) );
+	},
+
+	odd: function() {
+		return this.pushStack( jQuery.grep( this, function( _elem, i ) {
+			return i % 2;
+		} ) );
+	},
+
+	eq: function( i ) {
+		var len = this.length,
+			j = +i + ( i < 0 ? len : 0 );
+		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
+	},
+
+	end: function() {
+		return this.prevObject || this.constructor();
+	},
+
+	// For internal use only.
+	// Behaves like an Array's method, not like a jQuery method.
+	push: push,
+	sort: arr.sort,
+	splice: arr.splice
+};
+
+jQuery.extend = jQuery.fn.extend = function() {
+	var options, name, src, copy, copyIsArray, clone,
+		target = arguments[ 0 ] || {},
+		i = 1,
+		length = arguments.length,
+		deep = false;
+
+	// Handle a deep copy situation
+	if ( typeof target === "boolean" ) {
+		deep = target;
+
+		// Skip the boolean and the target
+		target = arguments[ i ] || {};
+		i++;
+	}
+
+	// Handle case when target is a string or something (possible in deep copy)
+	if ( typeof target !== "object" && !isFunction( target ) ) {
+		target = {};
+	}
+
+	// Extend jQuery itself if only one argument is passed
+	if ( i === length ) {
+		target = this;
+		i--;
+	}
+
+	for ( ; i < length; i++ ) {
+
+		// Only deal with non-null/undefined values
+		if ( ( options = arguments[ i ] ) != null ) {
+
+			// Extend the base object
+			for ( name in options ) {
+				copy = options[ name ];
+
+				// Prevent Object.prototype pollution
+				// Prevent never-ending loop
+				if ( name === "__proto__" || target === copy ) {
+					continue;
+				}
+
+				// Recurse if we're merging plain objects or arrays
+				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
+					( copyIsArray = Array.isArray( copy ) ) ) ) {
+					src = target[ name ];
+
+					// Ensure proper type for the source value
+					if ( copyIsArray && !Array.isArray( src ) ) {
+						clone = [];
+					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
+						clone = {};
+					} else {
+						clone = src;
+					}
+					copyIsArray = false;
+
+					// Never move original objects, clone them
+					target[ name ] = jQuery.extend( deep, clone, copy );
+
+				// Don't bring in undefined values
+				} else if ( copy !== undefined ) {
+					target[ name ] = copy;
+				}
+			}
+		}
+	}
+
+	// Return the modified object
+	return target;
+};
+
+jQuery.extend( {
+
+	// Unique for each copy of jQuery on the page
+	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
+
+	// Assume jQuery is ready without the ready module
+	isReady: true,
+
+	error: function( msg ) {
+		throw new Error( msg );
+	},
+
+	noop: function() {},
+
+	isPlainObject: function( obj ) {
+		var proto, Ctor;
+
+		// Detect obvious negatives
+		// Use toString instead of jQuery.type to catch host objects
+		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
+			return false;
+		}
+
+		proto = getProto( obj );
+
+		// Objects with no prototype (e.g., `Object.create( null )`) are plain
+		if ( !proto ) {
+			return true;
+		}
+
+		// Objects with prototype are plain iff they were constructed by a global Object function
+		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
+		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
+	},
+
+	isEmptyObject: function( obj ) {
+		var name;
+
+		for ( name in obj ) {
+			return false;
+		}
+		return true;
+	},
+
+	// Evaluates a script in a provided context; falls back to the global one
+	// if not specified.
+	globalEval: function( code, options, doc ) {
+		DOMEval( code, { nonce: options && options.nonce }, doc );
+	},
+
+	each: function( obj, callback ) {
+		var length, i = 0;
+
+		if ( isArrayLike( obj ) ) {
+			length = obj.length;
+			for ( ; i < length; i++ ) {
+				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
+					break;
+				}
+			}
+		} else {
+			for ( i in obj ) {
+				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
+					break;
+				}
+			}
+		}
+
+		return obj;
+	},
+
+
+	// Retrieve the text value of an array of DOM nodes
+	text: function( elem ) {
+		var node,
+			ret = "",
+			i = 0,
+			nodeType = elem.nodeType;
+
+		if ( !nodeType ) {
+
+			// If no nodeType, this is expected to be an array
+			while ( ( node = elem[ i++ ] ) ) {
+
+				// Do not traverse comment nodes
+				ret += jQuery.text( node );
+			}
+		}
+		if ( nodeType === 1 || nodeType === 11 ) {
+			return elem.textContent;
+		}
+		if ( nodeType === 9 ) {
+			return elem.documentElement.textContent;
+		}
+		if ( nodeType === 3 || nodeType === 4 ) {
+			return elem.nodeValue;
+		}
+
+		// Do not include comment or processing instruction nodes
+
+		return ret;
+	},
+
+	// results is for internal usage only
+	makeArray: function( arr, results ) {
+		var ret = results || [];
+
+		if ( arr != null ) {
+			if ( isArrayLike( Object( arr ) ) ) {
+				jQuery.merge( ret,
+					typeof arr === "string" ?
+						[ arr ] : arr
+				);
+			} else {
+				push.call( ret, arr );
+			}
+		}
+
+		return ret;
+	},
+
+	inArray: function( elem, arr, i ) {
+		return arr == null ? -1 : indexOf.call( arr, elem, i );
+	},
+
+	isXMLDoc: function( elem ) {
+		var namespace = elem && elem.namespaceURI,
+			docElem = elem && ( elem.ownerDocument || elem ).documentElement;
+
+		// Assume HTML when documentElement doesn't yet exist, such as inside
+		// document fragments.
+		return !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || "HTML" );
+	},
+
+	// Support: Android <=4.0 only, PhantomJS 1 only
+	// push.apply(_, arraylike) throws on ancient WebKit
+	merge: function( first, second ) {
+		var len = +second.length,
+			j = 0,
+			i = first.length;
+
+		for ( ; j < len; j++ ) {
+			first[ i++ ] = second[ j ];
+		}
+
+		first.length = i;
+
+		return first;
+	},
+
+	grep: function( elems, callback, invert ) {
+		var callbackInverse,
+			matches = [],
+			i = 0,
+			length = elems.length,
+			callbackExpect = !invert;
+
+		// Go through the array, only saving the items
+		// that pass the validator function
+		for ( ; i < length; i++ ) {
+			callbackInverse = !callback( elems[ i ], i );
+			if ( callbackInverse !== callbackExpect ) {
+				matches.push( elems[ i ] );
+			}
+		}
+
+		return matches;
+	},
+
+	// arg is for internal usage only
+	map: function( elems, callback, arg ) {
+		var length, value,
+			i = 0,
+			ret = [];
+
+		// Go through the array, translating each of the items to their new values
+		if ( isArrayLike( elems ) ) {
+			length = elems.length;
+			for ( ; i < length; i++ ) {
+				value = callback( elems[ i ], i, arg );
+
+				if ( value != null ) {
+					ret.push( value );
+				}
+			}
+
+		// Go through every key on the object,
+		} else {
+			for ( i in elems ) {
+				value = callback( elems[ i ], i, arg );
+
+				if ( value != null ) {
+					ret.push( value );
+				}
+			}
+		}
+
+		// Flatten any nested arrays
+		return flat( ret );
+	},
+
+	// A global GUID counter for objects
+	guid: 1,
+
+	// jQuery.support is not used in Core but other projects attach their
+	// properties to it so it needs to exist.
+	support: support
+} );
+
+if ( typeof Symbol === "function" ) {
+	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
+}
+
+// Populate the class2type map
+jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
+	function( _i, name ) {
+		class2type[ "[object " + name + "]" ] = name.toLowerCase();
+	} );
+
+function isArrayLike( obj ) {
+
+	// Support: real iOS 8.2 only (not reproducible in simulator)
+	// `in` check used to prevent JIT error (gh-2145)
+	// hasOwn isn't used here due to false negatives
+	// regarding Nodelist length in IE
+	var length = !!obj && "length" in obj && obj.length,
+		type = toType( obj );
+
+	if ( isFunction( obj ) || isWindow( obj ) ) {
+		return false;
+	}
+
+	return type === "array" || length === 0 ||
+		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
+}
+
+
+function nodeName( elem, name ) {
+
+	return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
+
+}
+var pop = arr.pop;
+
+
+var sort = arr.sort;
+
+
+var splice = arr.splice;
+
+
+var whitespace = "[\\x20\\t\\r\\n\\f]";
+
+
+var rtrimCSS = new RegExp(
+	"^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$",
+	"g"
+);
+
+
+
+
+// Note: an element does not contain itself
+jQuery.contains = function( a, b ) {
+	var bup = b && b.parentNode;
+
+	return a === bup || !!( bup && bup.nodeType === 1 && (
+
+		// Support: IE 9 - 11+
+		// IE doesn't have `contains` on SVG.
+		a.contains ?
+			a.contains( bup ) :
+			a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
+	) );
+};
+
+
+
+
+// CSS string/identifier serialization
+// https://drafts.csswg.org/cssom/#common-serializing-idioms
+var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g;
+
+function fcssescape( ch, asCodePoint ) {
+	if ( asCodePoint ) {
+
+		// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
+		if ( ch === "\0" ) {
+			return "\uFFFD";
+		}
+
+		// Control characters and (dependent upon position) numbers get escaped as code points
+		return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
+	}
+
+	// Other potentially-special ASCII characters get backslash-escaped
+	return "\\" + ch;
+}
+
+jQuery.escapeSelector = function( sel ) {
+	return ( sel + "" ).replace( rcssescape, fcssescape );
+};
+
+
+
+
+var preferredDoc = document,
+	pushNative = push;
+
+( function() {
+
+var i,
+	Expr,
+	outermostContext,
+	sortInput,
+	hasDuplicate,
+	push = pushNative,
+
+	// Local document vars
+	document,
+	documentElement,
+	documentIsHTML,
+	rbuggyQSA,
+	matches,
+
+	// Instance-specific data
+	expando = jQuery.expando,
+	dirruns = 0,
+	done = 0,
+	classCache = createCache(),
+	tokenCache = createCache(),
+	compilerCache = createCache(),
+	nonnativeSelectorCache = createCache(),
+	sortOrder = function( a, b ) {
+		if ( a === b ) {
+			hasDuplicate = true;
+		}
+		return 0;
+	},
+
+	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|" +
+		"loop|multiple|open|readonly|required|scoped",
+
+	// Regular expressions
+
+	// https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
+	identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
+		"?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
+
+	// Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors
+	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
+
+		// Operator (capture 2)
+		"*([*^$|!~]?=)" + whitespace +
+
+		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
+		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
+		whitespace + "*\\]",
+
+	pseudos = ":(" + identifier + ")(?:\\((" +
+
+		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
+		// 1. quoted (capture 3; capture 4 or capture 5)
+		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
+
+		// 2. simple (capture 6)
+		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
+
+		// 3. anything else (capture 2)
+		".*" +
+		")\\)|)",
+
+	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
+	rwhitespace = new RegExp( whitespace + "+", "g" ),
+
+	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
+	rleadingCombinator = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" +
+		whitespace + "*" ),
+	rdescend = new RegExp( whitespace + "|>" ),
+
+	rpseudo = new RegExp( pseudos ),
+	ridentifier = new RegExp( "^" + identifier + "$" ),
+
+	matchExpr = {
+		ID: new RegExp( "^#(" + identifier + ")" ),
+		CLASS: new RegExp( "^\\.(" + identifier + ")" ),
+		TAG: new RegExp( "^(" + identifier + "|[*])" ),
+		ATTR: new RegExp( "^" + attributes ),
+		PSEUDO: new RegExp( "^" + pseudos ),
+		CHILD: new RegExp(
+			"^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
+				whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
+				whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
+		bool: new RegExp( "^(?:" + booleans + ")$", "i" ),
+
+		// For use in libraries implementing .is()
+		// We use this for POS matching in `select`
+		needsContext: new RegExp( "^" + whitespace +
+			"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
+			"*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
+	},
+
+	rinputs = /^(?:input|select|textarea|button)$/i,
+	rheader = /^h\d$/i,
+
+	// Easily-parseable/retrievable ID or TAG or CLASS selectors
+	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
+
+	rsibling = /[+~]/,
+
+	// CSS escapes
+	// https://www.w3.org/TR/CSS21/syndata.html#escaped-characters
+	runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace +
+		"?|\\\\([^\\r\\n\\f])", "g" ),
+	funescape = function( escape, nonHex ) {
+		var high = "0x" + escape.slice( 1 ) - 0x10000;
+
+		if ( nonHex ) {
+
+			// Strip the backslash prefix from a non-hex escape sequence
+			return nonHex;
+		}
+
+		// Replace a hexadecimal escape sequence with the encoded Unicode code point
+		// Support: IE <=11+
+		// For values outside the Basic Multilingual Plane (BMP), manually construct a
+		// surrogate pair
+		return high < 0 ?
+			String.fromCharCode( high + 0x10000 ) :
+			String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
+	},
+
+	// Used for iframes; see `setDocument`.
+	// Support: IE 9 - 11+, Edge 12 - 18+
+	// Removing the function wrapper causes a "Permission Denied"
+	// error in IE/Edge.
+	unloadHandler = function() {
+		setDocument();
+	},
+
+	inDisabledFieldset = addCombinator(
+		function( elem ) {
+			return elem.disabled === true && nodeName( elem, "fieldset" );
+		},
+		{ dir: "parentNode", next: "legend" }
+	);
+
+// Support: IE <=9 only
+// Accessing document.activeElement can throw unexpectedly
+// https://bugs.jquery.com/ticket/13393
+function safeActiveElement() {
+	try {
+		return document.activeElement;
+	} catch ( err ) { }
+}
+
+// Optimize for push.apply( _, NodeList )
+try {
+	push.apply(
+		( arr = slice.call( preferredDoc.childNodes ) ),
+		preferredDoc.childNodes
+	);
+
+	// Support: Android <=4.0
+	// Detect silently failing push.apply
+	// eslint-disable-next-line no-unused-expressions
+	arr[ preferredDoc.childNodes.length ].nodeType;
+} catch ( e ) {
+	push = {
+		apply: function( target, els ) {
+			pushNative.apply( target, slice.call( els ) );
+		},
+		call: function( target ) {
+			pushNative.apply( target, slice.call( arguments, 1 ) );
+		}
+	};
+}
+
+function find( selector, context, results, seed ) {
+	var m, i, elem, nid, match, groups, newSelector,
+		newContext = context && context.ownerDocument,
+
+		// nodeType defaults to 9, since context defaults to document
+		nodeType = context ? context.nodeType : 9;
+
+	results = results || [];
+
+	// Return early from calls with invalid selector or context
+	if ( typeof selector !== "string" || !selector ||
+		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
+
+		return results;
+	}
+
+	// Try to shortcut find operations (as opposed to filters) in HTML documents
+	if ( !seed ) {
+		setDocument( context );
+		context = context || document;
+
+		if ( documentIsHTML ) {
+
+			// If the selector is sufficiently simple, try using a "get*By*" DOM method
+			// (excepting DocumentFragment context, where the methods don't exist)
+			if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
+
+				// ID selector
+				if ( ( m = match[ 1 ] ) ) {
+
+					// Document context
+					if ( nodeType === 9 ) {
+						if ( ( elem = context.getElementById( m ) ) ) {
+
+							// Support: IE 9 only
+							// getElementById can match elements by name instead of ID
+							if ( elem.id === m ) {
+								push.call( results, elem );
+								return results;
+							}
+						} else {
+							return results;
+						}
+
+					// Element context
+					} else {
+
+						// Support: IE 9 only
+						// getElementById can match elements by name instead of ID
+						if ( newContext && ( elem = newContext.getElementById( m ) ) &&
+							find.contains( context, elem ) &&
+							elem.id === m ) {
+
+							push.call( results, elem );
+							return results;
+						}
+					}
+
+				// Type selector
+				} else if ( match[ 2 ] ) {
+					push.apply( results, context.getElementsByTagName( selector ) );
+					return results;
+
+				// Class selector
+				} else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) {
+					push.apply( results, context.getElementsByClassName( m ) );
+					return results;
+				}
+			}
+
+			// Take advantage of querySelectorAll
+			if ( !nonnativeSelectorCache[ selector + " " ] &&
+				( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) {
+
+				newSelector = selector;
+				newContext = context;
+
+				// qSA considers elements outside a scoping root when evaluating child or
+				// descendant combinators, which is not what we want.
+				// In such cases, we work around the behavior by prefixing every selector in the
+				// list with an ID selector referencing the scope context.
+				// The technique has to be used as well when a leading combinator is used
+				// as such selectors are not recognized by querySelectorAll.
+				// Thanks to Andrew Dupont for this technique.
+				if ( nodeType === 1 &&
+					( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) {
+
+					// Expand context for sibling selectors
+					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
+						context;
+
+					// We can use :scope instead of the ID hack if the browser
+					// supports it & if we're not changing the context.
+					// Support: IE 11+, Edge 17 - 18+
+					// IE/Edge sometimes throw a "Permission denied" error when
+					// strict-comparing two documents; shallow comparisons work.
+					// eslint-disable-next-line eqeqeq
+					if ( newContext != context || !support.scope ) {
+
+						// Capture the context ID, setting it first if necessary
+						if ( ( nid = context.getAttribute( "id" ) ) ) {
+							nid = jQuery.escapeSelector( nid );
+						} else {
+							context.setAttribute( "id", ( nid = expando ) );
+						}
+					}
+
+					// Prefix every selector in the list
+					groups = tokenize( selector );
+					i = groups.length;
+					while ( i-- ) {
+						groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
+							toSelector( groups[ i ] );
+					}
+					newSelector = groups.join( "," );
+				}
+
+				try {
+					push.apply( results,
+						newContext.querySelectorAll( newSelector )
+					);
+					return results;
+				} catch ( qsaError ) {
+					nonnativeSelectorCache( selector, true );
+				} finally {
+					if ( nid === expando ) {
+						context.removeAttribute( "id" );
+					}
+				}
+			}
+		}
+	}
+
+	// All others
+	return select( selector.replace( rtrimCSS, "$1" ), context, results, seed );
+}
+
+/**
+ * Create key-value caches of limited size
+ * @returns {function(string, object)} Returns the Object data after storing it on itself with
+ *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
+ *	deleting the oldest entry
+ */
+function createCache() {
+	var keys = [];
+
+	function cache( key, value ) {
+
+		// Use (key + " ") to avoid collision with native prototype properties
+		// (see https://github.com/jquery/sizzle/issues/157)
+		if ( keys.push( key + " " ) > Expr.cacheLength ) {
+
+			// Only keep the most recent entries
+			delete cache[ keys.shift() ];
+		}
+		return ( cache[ key + " " ] = value );
+	}
+	return cache;
+}
+
+/**
+ * Mark a function for special use by jQuery selector module
+ * @param {Function} fn The function to mark
+ */
+function markFunction( fn ) {
+	fn[ expando ] = true;
+	return fn;
+}
+
+/**
+ * Support testing using an element
+ * @param {Function} fn Passed the created element and returns a boolean result
+ */
+function assert( fn ) {
+	var el = document.createElement( "fieldset" );
+
+	try {
+		return !!fn( el );
+	} catch ( e ) {
+		return false;
+	} finally {
+
+		// Remove from its parent by default
+		if ( el.parentNode ) {
+			el.parentNode.removeChild( el );
+		}
+
+		// release memory in IE
+		el = null;
+	}
+}
+
+/**
+ * Returns a function to use in pseudos for input types
+ * @param {String} type
+ */
+function createInputPseudo( type ) {
+	return function( elem ) {
+		return nodeName( elem, "input" ) && elem.type === type;
+	};
+}
+
+/**
+ * Returns a function to use in pseudos for buttons
+ * @param {String} type
+ */
+function createButtonPseudo( type ) {
+	return function( elem ) {
+		return ( nodeName( elem, "input" ) || nodeName( elem, "button" ) ) &&
+			elem.type === type;
+	};
+}
+
+/**
+ * Returns a function to use in pseudos for :enabled/:disabled
+ * @param {Boolean} disabled true for :disabled; false for :enabled
+ */
+function createDisabledPseudo( disabled ) {
+
+	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
+	return function( elem ) {
+
+		// Only certain elements can match :enabled or :disabled
+		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
+		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
+		if ( "form" in elem ) {
+
+			// Check for inherited disabledness on relevant non-disabled elements:
+			// * listed form-associated elements in a disabled fieldset
+			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
+			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
+			// * option elements in a disabled optgroup
+			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
+			// All such elements have a "form" property.
+			if ( elem.parentNode && elem.disabled === false ) {
+
+				// Option elements defer to a parent optgroup if present
+				if ( "label" in elem ) {
+					if ( "label" in elem.parentNode ) {
+						return elem.parentNode.disabled === disabled;
+					} else {
+						return elem.disabled === disabled;
+					}
+				}
+
+				// Support: IE 6 - 11+
+				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
+				return elem.isDisabled === disabled ||
+
+					// Where there is no isDisabled, check manually
+					elem.isDisabled !== !disabled &&
+						inDisabledFieldset( elem ) === disabled;
+			}
+
+			return elem.disabled === disabled;
+
+		// Try to winnow out elements that can't be disabled before trusting the disabled property.
+		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
+		// even exist on them, let alone have a boolean value.
+		} else if ( "label" in elem ) {
+			return elem.disabled === disabled;
+		}
+
+		// Remaining elements are neither :enabled nor :disabled
+		return false;
+	};
+}
+
+/**
+ * Returns a function to use in pseudos for positionals
+ * @param {Function} fn
+ */
+function createPositionalPseudo( fn ) {
+	return markFunction( function( argument ) {
+		argument = +argument;
+		return markFunction( function( seed, matches ) {
+			var j,
+				matchIndexes = fn( [], seed.length, argument ),
+				i = matchIndexes.length;
+
+			// Match elements found at the specified indexes
+			while ( i-- ) {
+				if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
+					seed[ j ] = !( matches[ j ] = seed[ j ] );
+				}
+			}
+		} );
+	} );
+}
+
+/**
+ * Checks a node for validity as a jQuery selector context
+ * @param {Element|Object=} context
+ * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
+ */
+function testContext( context ) {
+	return context && typeof context.getElementsByTagName !== "undefined" && context;
+}
+
+/**
+ * Sets document-related variables once based on the current document
+ * @param {Element|Object} [node] An element or document object to use to set the document
+ * @returns {Object} Returns the current document
+ */
+function setDocument( node ) {
+	var subWindow,
+		doc = node ? node.ownerDocument || node : preferredDoc;
+
+	// Return early if doc is invalid or already selected
+	// Support: IE 11+, Edge 17 - 18+
+	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+	// two documents; shallow comparisons work.
+	// eslint-disable-next-line eqeqeq
+	if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
+		return document;
+	}
+
+	// Update global variables
+	document = doc;
+	documentElement = document.documentElement;
+	documentIsHTML = !jQuery.isXMLDoc( document );
+
+	// Support: iOS 7 only, IE 9 - 11+
+	// Older browsers didn't support unprefixed `matches`.
+	matches = documentElement.matches ||
+		documentElement.webkitMatchesSelector ||
+		documentElement.msMatchesSelector;
+
+	// Support: IE 9 - 11+, Edge 12 - 18+
+	// Accessing iframe documents after unload throws "permission denied" errors
+	// (see trac-13936).
+	// Limit the fix to IE & Edge Legacy; despite Edge 15+ implementing `matches`,
+	// all IE 9+ and Edge Legacy versions implement `msMatchesSelector` as well.
+	if ( documentElement.msMatchesSelector &&
+
+		// Support: IE 11+, Edge 17 - 18+
+		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+		// two documents; shallow comparisons work.
+		// eslint-disable-next-line eqeqeq
+		preferredDoc != document &&
+		( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
+
+		// Support: IE 9 - 11+, Edge 12 - 18+
+		subWindow.addEventListener( "unload", unloadHandler );
+	}
+
+	// Support: IE <10
+	// Check if getElementById returns elements by name
+	// The broken getElementById methods don't pick up programmatically-set names,
+	// so use a roundabout getElementsByName test
+	support.getById = assert( function( el ) {
+		documentElement.appendChild( el ).id = jQuery.expando;
+		return !document.getElementsByName ||
+			!document.getElementsByName( jQuery.expando ).length;
+	} );
+
+	// Support: IE 9 only
+	// Check to see if it's possible to do matchesSelector
+	// on a disconnected node.
+	support.disconnectedMatch = assert( function( el ) {
+		return matches.call( el, "*" );
+	} );
+
+	// Support: IE 9 - 11+, Edge 12 - 18+
+	// IE/Edge don't support the :scope pseudo-class.
+	support.scope = assert( function() {
+		return document.querySelectorAll( ":scope" );
+	} );
+
+	// Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only
+	// Make sure the `:has()` argument is parsed unforgivingly.
+	// We include `*` in the test to detect buggy implementations that are
+	// _selectively_ forgiving (specifically when the list includes at least
+	// one valid selector).
+	// Note that we treat complete lack of support for `:has()` as if it were
+	// spec-compliant support, which is fine because use of `:has()` in such
+	// environments will fail in the qSA path and fall back to jQuery traversal
+	// anyway.
+	support.cssHas = assert( function() {
+		try {
+			document.querySelector( ":has(*,:jqfake)" );
+			return false;
+		} catch ( e ) {
+			return true;
+		}
+	} );
+
+	// ID filter and find
+	if ( support.getById ) {
+		Expr.filter.ID = function( id ) {
+			var attrId = id.replace( runescape, funescape );
+			return function( elem ) {
+				return elem.getAttribute( "id" ) === attrId;
+			};
+		};
+		Expr.find.ID = function( id, context ) {
+			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
+				var elem = context.getElementById( id );
+				return elem ? [ elem ] : [];
+			}
+		};
+	} else {
+		Expr.filter.ID =  function( id ) {
+			var attrId = id.replace( runescape, funescape );
+			return function( elem ) {
+				var node = typeof elem.getAttributeNode !== "undefined" &&
+					elem.getAttributeNode( "id" );
+				return node && node.value === attrId;
+			};
+		};
+
+		// Support: IE 6 - 7 only
+		// getElementById is not reliable as a find shortcut
+		Expr.find.ID = function( id, context ) {
+			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
+				var node, i, elems,
+					elem = context.getElementById( id );
+
+				if ( elem ) {
+
+					// Verify the id attribute
+					node = elem.getAttributeNode( "id" );
+					if ( node && node.value === id ) {
+						return [ elem ];
+					}
+
+					// Fall back on getElementsByName
+					elems = context.getElementsByName( id );
+					i = 0;
+					while ( ( elem = elems[ i++ ] ) ) {
+						node = elem.getAttributeNode( "id" );
+						if ( node && node.value === id ) {
+							return [ elem ];
+						}
+					}
+				}
+
+				return [];
+			}
+		};
+	}
+
+	// Tag
+	Expr.find.TAG = function( tag, context ) {
+		if ( typeof context.getElementsByTagName !== "undefined" ) {
+			return context.getElementsByTagName( tag );
+
+		// DocumentFragment nodes don't have gEBTN
+		} else {
+			return context.querySelectorAll( tag );
+		}
+	};
+
+	// Class
+	Expr.find.CLASS = function( className, context ) {
+		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
+			return context.getElementsByClassName( className );
+		}
+	};
+
+	/* QSA/matchesSelector
+	---------------------------------------------------------------------- */
+
+	// QSA and matchesSelector support
+
+	rbuggyQSA = [];
+
+	// Build QSA regex
+	// Regex strategy adopted from Diego Perini
+	assert( function( el ) {
+
+		var input;
+
+		documentElement.appendChild( el ).innerHTML =
+			"<a id='" + expando + "' href='' disabled='disabled'></a>" +
+			"<select id='" + expando + "-\r\\' disabled='disabled'>" +
+			"<option selected=''></option></select>";
+
+		// Support: iOS <=7 - 8 only
+		// Boolean attributes and "value" are not treated correctly in some XML documents
+		if ( !el.querySelectorAll( "[selected]" ).length ) {
+			rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
+		}
+
+		// Support: iOS <=7 - 8 only
+		if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
+			rbuggyQSA.push( "~=" );
+		}
+
+		// Support: iOS 8 only
+		// https://bugs.webkit.org/show_bug.cgi?id=136851
+		// In-page `selector#id sibling-combinator selector` fails
+		if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
+			rbuggyQSA.push( ".#.+[+~]" );
+		}
+
+		// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+
+		// In some of the document kinds, these selectors wouldn't work natively.
+		// This is probably OK but for backwards compatibility we want to maintain
+		// handling them through jQuery traversal in jQuery 3.x.
+		if ( !el.querySelectorAll( ":checked" ).length ) {
+			rbuggyQSA.push( ":checked" );
+		}
+
+		// Support: Windows 8 Native Apps
+		// The type and name attributes are restricted during .innerHTML assignment
+		input = document.createElement( "input" );
+		input.setAttribute( "type", "hidden" );
+		el.appendChild( input ).setAttribute( "name", "D" );
+
+		// Support: IE 9 - 11+
+		// IE's :disabled selector does not pick up the children of disabled fieldsets
+		// Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+
+		// In some of the document kinds, these selectors wouldn't work natively.
+		// This is probably OK but for backwards compatibility we want to maintain
+		// handling them through jQuery traversal in jQuery 3.x.
+		documentElement.appendChild( el ).disabled = true;
+		if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
+			rbuggyQSA.push( ":enabled", ":disabled" );
+		}
+
+		// Support: IE 11+, Edge 15 - 18+
+		// IE 11/Edge don't find elements on a `[name='']` query in some cases.
+		// Adding a temporary attribute to the document before the selection works
+		// around the issue.
+		// Interestingly, IE 10 & older don't seem to have the issue.
+		input = document.createElement( "input" );
+		input.setAttribute( "name", "" );
+		el.appendChild( input );
+		if ( !el.querySelectorAll( "[name='']" ).length ) {
+			rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
+				whitespace + "*(?:''|\"\")" );
+		}
+	} );
+
+	if ( !support.cssHas ) {
+
+		// Support: Chrome 105 - 110+, Safari 15.4 - 16.3+
+		// Our regular `try-catch` mechanism fails to detect natively-unsupported
+		// pseudo-classes inside `:has()` (such as `:has(:contains("Foo"))`)
+		// in browsers that parse the `:has()` argument as a forgiving selector list.
+		// https://drafts.csswg.org/selectors/#relational now requires the argument
+		// to be parsed unforgivingly, but browsers have not yet fully adjusted.
+		rbuggyQSA.push( ":has" );
+	}
+
+	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
+
+	/* Sorting
+	---------------------------------------------------------------------- */
+
+	// Document order sorting
+	sortOrder = function( a, b ) {
+
+		// Flag for duplicate removal
+		if ( a === b ) {
+			hasDuplicate = true;
+			return 0;
+		}
+
+		// Sort on method existence if only one input has compareDocumentPosition
+		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
+		if ( compare ) {
+			return compare;
+		}
+
+		// Calculate position if both inputs belong to the same document
+		// Support: IE 11+, Edge 17 - 18+
+		// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+		// two documents; shallow comparisons work.
+		// eslint-disable-next-line eqeqeq
+		compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
+			a.compareDocumentPosition( b ) :
+
+			// Otherwise we know they are disconnected
+			1;
+
+		// Disconnected nodes
+		if ( compare & 1 ||
+			( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
+
+			// Choose the first element that is related to our preferred document
+			// Support: IE 11+, Edge 17 - 18+
+			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+			// two documents; shallow comparisons work.
+			// eslint-disable-next-line eqeqeq
+			if ( a === document || a.ownerDocument == preferredDoc &&
+				find.contains( preferredDoc, a ) ) {
+				return -1;
+			}
+
+			// Support: IE 11+, Edge 17 - 18+
+			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+			// two documents; shallow comparisons work.
+			// eslint-disable-next-line eqeqeq
+			if ( b === document || b.ownerDocument == preferredDoc &&
+				find.contains( preferredDoc, b ) ) {
+				return 1;
+			}
+
+			// Maintain original order
+			return sortInput ?
+				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
+				0;
+		}
+
+		return compare & 4 ? -1 : 1;
+	};
+
+	return document;
+}
+
+find.matches = function( expr, elements ) {
+	return find( expr, null, null, elements );
+};
+
+find.matchesSelector = function( elem, expr ) {
+	setDocument( elem );
+
+	if ( documentIsHTML &&
+		!nonnativeSelectorCache[ expr + " " ] &&
+		( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) {
+
+		try {
+			var ret = matches.call( elem, expr );
+
+			// IE 9's matchesSelector returns false on disconnected nodes
+			if ( ret || support.disconnectedMatch ||
+
+					// As well, disconnected nodes are said to be in a document
+					// fragment in IE 9
+					elem.document && elem.document.nodeType !== 11 ) {
+				return ret;
+			}
+		} catch ( e ) {
+			nonnativeSelectorCache( expr, true );
+		}
+	}
+
+	return find( expr, document, null, [ elem ] ).length > 0;
+};
+
+find.contains = function( context, elem ) {
+
+	// Set document vars if needed
+	// Support: IE 11+, Edge 17 - 18+
+	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+	// two documents; shallow comparisons work.
+	// eslint-disable-next-line eqeqeq
+	if ( ( context.ownerDocument || context ) != document ) {
+		setDocument( context );
+	}
+	return jQuery.contains( context, elem );
+};
+
+
+find.attr = function( elem, name ) {
+
+	// Set document vars if needed
+	// Support: IE 11+, Edge 17 - 18+
+	// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+	// two documents; shallow comparisons work.
+	// eslint-disable-next-line eqeqeq
+	if ( ( elem.ownerDocument || elem ) != document ) {
+		setDocument( elem );
+	}
+
+	var fn = Expr.attrHandle[ name.toLowerCase() ],
+
+		// Don't get fooled by Object.prototype properties (see trac-13807)
+		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
+			fn( elem, name, !documentIsHTML ) :
+			undefined;
+
+	if ( val !== undefined ) {
+		return val;
+	}
+
+	return elem.getAttribute( name );
+};
+
+find.error = function( msg ) {
+	throw new Error( "Syntax error, unrecognized expression: " + msg );
+};
+
+/**
+ * Document sorting and removing duplicates
+ * @param {ArrayLike} results
+ */
+jQuery.uniqueSort = function( results ) {
+	var elem,
+		duplicates = [],
+		j = 0,
+		i = 0;
+
+	// Unless we *know* we can detect duplicates, assume their presence
+	//
+	// Support: Android <=4.0+
+	// Testing for detecting duplicates is unpredictable so instead assume we can't
+	// depend on duplicate detection in all browsers without a stable sort.
+	hasDuplicate = !support.sortStable;
+	sortInput = !support.sortStable && slice.call( results, 0 );
+	sort.call( results, sortOrder );
+
+	if ( hasDuplicate ) {
+		while ( ( elem = results[ i++ ] ) ) {
+			if ( elem === results[ i ] ) {
+				j = duplicates.push( i );
+			}
+		}
+		while ( j-- ) {
+			splice.call( results, duplicates[ j ], 1 );
+		}
+	}
+
+	// Clear input after sorting to release objects
+	// See https://github.com/jquery/sizzle/pull/225
+	sortInput = null;
+
+	return results;
+};
+
+jQuery.fn.uniqueSort = function() {
+	return this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) );
+};
+
+Expr = jQuery.expr = {
+
+	// Can be adjusted by the user
+	cacheLength: 50,
+
+	createPseudo: markFunction,
+
+	match: matchExpr,
+
+	attrHandle: {},
+
+	find: {},
+
+	relative: {
+		">": { dir: "parentNode", first: true },
+		" ": { dir: "parentNode" },
+		"+": { dir: "previousSibling", first: true },
+		"~": { dir: "previousSibling" }
+	},
+
+	preFilter: {
+		ATTR: function( match ) {
+			match[ 1 ] = match[ 1 ].replace( runescape, funescape );
+
+			// Move the given value to match[3] whether quoted or unquoted
+			match[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || "" )
+				.replace( runescape, funescape );
+
+			if ( match[ 2 ] === "~=" ) {
+				match[ 3 ] = " " + match[ 3 ] + " ";
+			}
+
+			return match.slice( 0, 4 );
+		},
+
+		CHILD: function( match ) {
+
+			/* matches from matchExpr["CHILD"]
+				1 type (only|nth|...)
+				2 what (child|of-type)
+				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
+				4 xn-component of xn+y argument ([+-]?\d*n|)
+				5 sign of xn-component
+				6 x of xn-component
+				7 sign of y-component
+				8 y of y-component
+			*/
+			match[ 1 ] = match[ 1 ].toLowerCase();
+
+			if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
+
+				// nth-* requires argument
+				if ( !match[ 3 ] ) {
+					find.error( match[ 0 ] );
+				}
+
+				// numeric x and y parameters for Expr.filter.CHILD
+				// remember that false/true cast respectively to 0/1
+				match[ 4 ] = +( match[ 4 ] ?
+					match[ 5 ] + ( match[ 6 ] || 1 ) :
+					2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" )
+				);
+				match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
+
+			// other types prohibit arguments
+			} else if ( match[ 3 ] ) {
+				find.error( match[ 0 ] );
+			}
+
+			return match;
+		},
+
+		PSEUDO: function( match ) {
+			var excess,
+				unquoted = !match[ 6 ] && match[ 2 ];
+
+			if ( matchExpr.CHILD.test( match[ 0 ] ) ) {
+				return null;
+			}
+
+			// Accept quoted arguments as-is
+			if ( match[ 3 ] ) {
+				match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
+
+			// Strip excess characters from unquoted arguments
+			} else if ( unquoted && rpseudo.test( unquoted ) &&
+
+				// Get excess from tokenize (recursively)
+				( excess = tokenize( unquoted, true ) ) &&
+
+				// advance to the next closing parenthesis
+				( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
+
+				// excess is a negative index
+				match[ 0 ] = match[ 0 ].slice( 0, excess );
+				match[ 2 ] = unquoted.slice( 0, excess );
+			}
+
+			// Return only captures needed by the pseudo filter method (type and argument)
+			return match.slice( 0, 3 );
+		}
+	},
+
+	filter: {
+
+		TAG: function( nodeNameSelector ) {
+			var expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
+			return nodeNameSelector === "*" ?
+				function() {
+					return true;
+				} :
+				function( elem ) {
+					return nodeName( elem, expectedNodeName );
+				};
+		},
+
+		CLASS: function( className ) {
+			var pattern = classCache[ className + " " ];
+
+			return pattern ||
+				( pattern = new RegExp( "(^|" + whitespace + ")" + className +
+					"(" + whitespace + "|$)" ) ) &&
+				classCache( className, function( elem ) {
+					return pattern.test(
+						typeof elem.className === "string" && elem.className ||
+							typeof elem.getAttribute !== "undefined" &&
+								elem.getAttribute( "class" ) ||
+							""
+					);
+				} );
+		},
+
+		ATTR: function( name, operator, check ) {
+			return function( elem ) {
+				var result = find.attr( elem, name );
+
+				if ( result == null ) {
+					return operator === "!=";
+				}
+				if ( !operator ) {
+					return true;
+				}
+
+				result += "";
+
+				if ( operator === "=" ) {
+					return result === check;
+				}
+				if ( operator === "!=" ) {
+					return result !== check;
+				}
+				if ( operator === "^=" ) {
+					return check && result.indexOf( check ) === 0;
+				}
+				if ( operator === "*=" ) {
+					return check && result.indexOf( check ) > -1;
+				}
+				if ( operator === "$=" ) {
+					return check && result.slice( -check.length ) === check;
+				}
+				if ( operator === "~=" ) {
+					return ( " " + result.replace( rwhitespace, " " ) + " " )
+						.indexOf( check ) > -1;
+				}
+				if ( operator === "|=" ) {
+					return result === check || result.slice( 0, check.length + 1 ) === check + "-";
+				}
+
+				return false;
+			};
+		},
+
+		CHILD: function( type, what, _argument, first, last ) {
+			var simple = type.slice( 0, 3 ) !== "nth",
+				forward = type.slice( -4 ) !== "last",
+				ofType = what === "of-type";
+
+			return first === 1 && last === 0 ?
+
+				// Shortcut for :nth-*(n)
+				function( elem ) {
+					return !!elem.parentNode;
+				} :
+
+				function( elem, _context, xml ) {
+					var cache, outerCache, node, nodeIndex, start,
+						dir = simple !== forward ? "nextSibling" : "previousSibling",
+						parent = elem.parentNode,
+						name = ofType && elem.nodeName.toLowerCase(),
+						useCache = !xml && !ofType,
+						diff = false;
+
+					if ( parent ) {
+
+						// :(first|last|only)-(child|of-type)
+						if ( simple ) {
+							while ( dir ) {
+								node = elem;
+								while ( ( node = node[ dir ] ) ) {
+									if ( ofType ?
+										nodeName( node, name ) :
+										node.nodeType === 1 ) {
+
+										return false;
+									}
+								}
+
+								// Reverse direction for :only-* (if we haven't yet done so)
+								start = dir = type === "only" && !start && "nextSibling";
+							}
+							return true;
+						}
+
+						start = [ forward ? parent.firstChild : parent.lastChild ];
+
+						// non-xml :nth-child(...) stores cache data on `parent`
+						if ( forward && useCache ) {
+
+							// Seek `elem` from a previously-cached index
+							outerCache = parent[ expando ] || ( parent[ expando ] = {} );
+							cache = outerCache[ type ] || [];
+							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
+							diff = nodeIndex && cache[ 2 ];
+							node = nodeIndex && parent.childNodes[ nodeIndex ];
+
+							while ( ( node = ++nodeIndex && node && node[ dir ] ||
+
+								// Fallback to seeking `elem` from the start
+								( diff = nodeIndex = 0 ) || start.pop() ) ) {
+
+								// When found, cache indexes on `parent` and break
+								if ( node.nodeType === 1 && ++diff && node === elem ) {
+									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
+									break;
+								}
+							}
+
+						} else {
+
+							// Use previously-cached element index if available
+							if ( useCache ) {
+								outerCache = elem[ expando ] || ( elem[ expando ] = {} );
+								cache = outerCache[ type ] || [];
+								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
+								diff = nodeIndex;
+							}
+
+							// xml :nth-child(...)
+							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
+							if ( diff === false ) {
+
+								// Use the same loop as above to seek `elem` from the start
+								while ( ( node = ++nodeIndex && node && node[ dir ] ||
+									( diff = nodeIndex = 0 ) || start.pop() ) ) {
+
+									if ( ( ofType ?
+										nodeName( node, name ) :
+										node.nodeType === 1 ) &&
+										++diff ) {
+
+										// Cache the index of each encountered element
+										if ( useCache ) {
+											outerCache = node[ expando ] ||
+												( node[ expando ] = {} );
+											outerCache[ type ] = [ dirruns, diff ];
+										}
+
+										if ( node === elem ) {
+											break;
+										}
+									}
+								}
+							}
+						}
+
+						// Incorporate the offset, then check against cycle size
+						diff -= last;
+						return diff === first || ( diff % first === 0 && diff / first >= 0 );
+					}
+				};
+		},
+
+		PSEUDO: function( pseudo, argument ) {
+
+			// pseudo-class names are case-insensitive
+			// https://www.w3.org/TR/selectors/#pseudo-classes
+			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
+			// Remember that setFilters inherits from pseudos
+			var args,
+				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
+					find.error( "unsupported pseudo: " + pseudo );
+
+			// The user may use createPseudo to indicate that
+			// arguments are needed to create the filter function
+			// just as jQuery does
+			if ( fn[ expando ] ) {
+				return fn( argument );
+			}
+
+			// But maintain support for old signatures
+			if ( fn.length > 1 ) {
+				args = [ pseudo, pseudo, "", argument ];
+				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
+					markFunction( function( seed, matches ) {
+						var idx,
+							matched = fn( seed, argument ),
+							i = matched.length;
+						while ( i-- ) {
+							idx = indexOf.call( seed, matched[ i ] );
+							seed[ idx ] = !( matches[ idx ] = matched[ i ] );
+						}
+					} ) :
+					function( elem ) {
+						return fn( elem, 0, args );
+					};
+			}
+
+			return fn;
+		}
+	},
+
+	pseudos: {
+
+		// Potentially complex pseudos
+		not: markFunction( function( selector ) {
+
+			// Trim the selector passed to compile
+			// to avoid treating leading and trailing
+			// spaces as combinators
+			var input = [],
+				results = [],
+				matcher = compile( selector.replace( rtrimCSS, "$1" ) );
+
+			return matcher[ expando ] ?
+				markFunction( function( seed, matches, _context, xml ) {
+					var elem,
+						unmatched = matcher( seed, null, xml, [] ),
+						i = seed.length;
+
+					// Match elements unmatched by `matcher`
+					while ( i-- ) {
+						if ( ( elem = unmatched[ i ] ) ) {
+							seed[ i ] = !( matches[ i ] = elem );
+						}
+					}
+				} ) :
+				function( elem, _context, xml ) {
+					input[ 0 ] = elem;
+					matcher( input, null, xml, results );
+
+					// Don't keep the element
+					// (see https://github.com/jquery/sizzle/issues/299)
+					input[ 0 ] = null;
+					return !results.pop();
+				};
+		} ),
+
+		has: markFunction( function( selector ) {
+			return function( elem ) {
+				return find( selector, elem ).length > 0;
+			};
+		} ),
+
+		contains: markFunction( function( text ) {
+			text = text.replace( runescape, funescape );
+			return function( elem ) {
+				return ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1;
+			};
+		} ),
+
+		// "Whether an element is represented by a :lang() selector
+		// is based solely on the element's language value
+		// being equal to the identifier C,
+		// or beginning with the identifier C immediately followed by "-".
+		// The matching of C against the element's language value is performed case-insensitively.
+		// The identifier C does not have to be a valid language name."
+		// https://www.w3.org/TR/selectors/#lang-pseudo
+		lang: markFunction( function( lang ) {
+
+			// lang value must be a valid identifier
+			if ( !ridentifier.test( lang || "" ) ) {
+				find.error( "unsupported lang: " + lang );
+			}
+			lang = lang.replace( runescape, funescape ).toLowerCase();
+			return function( elem ) {
+				var elemLang;
+				do {
+					if ( ( elemLang = documentIsHTML ?
+						elem.lang :
+						elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
+
+						elemLang = elemLang.toLowerCase();
+						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
+					}
+				} while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
+				return false;
+			};
+		} ),
+
+		// Miscellaneous
+		target: function( elem ) {
+			var hash = window.location && window.location.hash;
+			return hash && hash.slice( 1 ) === elem.id;
+		},
+
+		root: function( elem ) {
+			return elem === documentElement;
+		},
+
+		focus: function( elem ) {
+			return elem === safeActiveElement() &&
+				document.hasFocus() &&
+				!!( elem.type || elem.href || ~elem.tabIndex );
+		},
+
+		// Boolean properties
+		enabled: createDisabledPseudo( false ),
+		disabled: createDisabledPseudo( true ),
+
+		checked: function( elem ) {
+
+			// In CSS3, :checked should return both checked and selected elements
+			// https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
+			return ( nodeName( elem, "input" ) && !!elem.checked ) ||
+				( nodeName( elem, "option" ) && !!elem.selected );
+		},
+
+		selected: function( elem ) {
+
+			// Support: IE <=11+
+			// Accessing the selectedIndex property
+			// forces the browser to treat the default option as
+			// selected when in an optgroup.
+			if ( elem.parentNode ) {
+				// eslint-disable-next-line no-unused-expressions
+				elem.parentNode.selectedIndex;
+			}
+
+			return elem.selected === true;
+		},
+
+		// Contents
+		empty: function( elem ) {
+
+			// https://www.w3.org/TR/selectors/#empty-pseudo
+			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
+			//   but not by others (comment: 8; processing instruction: 7; etc.)
+			// nodeType < 6 works because attributes (2) do not appear as children
+			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
+				if ( elem.nodeType < 6 ) {
+					return false;
+				}
+			}
+			return true;
+		},
+
+		parent: function( elem ) {
+			return !Expr.pseudos.empty( elem );
+		},
+
+		// Element/input types
+		header: function( elem ) {
+			return rheader.test( elem.nodeName );
+		},
+
+		input: function( elem ) {
+			return rinputs.test( elem.nodeName );
+		},
+
+		button: function( elem ) {
+			return nodeName( elem, "input" ) && elem.type === "button" ||
+				nodeName( elem, "button" );
+		},
+
+		text: function( elem ) {
+			var attr;
+			return nodeName( elem, "input" ) && elem.type === "text" &&
+
+				// Support: IE <10 only
+				// New HTML5 attribute values (e.g., "search") appear
+				// with elem.type === "text"
+				( ( attr = elem.getAttribute( "type" ) ) == null ||
+					attr.toLowerCase() === "text" );
+		},
+
+		// Position-in-collection
+		first: createPositionalPseudo( function() {
+			return [ 0 ];
+		} ),
+
+		last: createPositionalPseudo( function( _matchIndexes, length ) {
+			return [ length - 1 ];
+		} ),
+
+		eq: createPositionalPseudo( function( _matchIndexes, length, argument ) {
+			return [ argument < 0 ? argument + length : argument ];
+		} ),
+
+		even: createPositionalPseudo( function( matchIndexes, length ) {
+			var i = 0;
+			for ( ; i < length; i += 2 ) {
+				matchIndexes.push( i );
+			}
+			return matchIndexes;
+		} ),
+
+		odd: createPositionalPseudo( function( matchIndexes, length ) {
+			var i = 1;
+			for ( ; i < length; i += 2 ) {
+				matchIndexes.push( i );
+			}
+			return matchIndexes;
+		} ),
+
+		lt: createPositionalPseudo( function( matchIndexes, length, argument ) {
+			var i;
+
+			if ( argument < 0 ) {
+				i = argument + length;
+			} else if ( argument > length ) {
+				i = length;
+			} else {
+				i = argument;
+			}
+
+			for ( ; --i >= 0; ) {
+				matchIndexes.push( i );
+			}
+			return matchIndexes;
+		} ),
+
+		gt: createPositionalPseudo( function( matchIndexes, length, argument ) {
+			var i = argument < 0 ? argument + length : argument;
+			for ( ; ++i < length; ) {
+				matchIndexes.push( i );
+			}
+			return matchIndexes;
+		} )
+	}
+};
+
+Expr.pseudos.nth = Expr.pseudos.eq;
+
+// Add button/input type pseudos
+for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
+	Expr.pseudos[ i ] = createInputPseudo( i );
+}
+for ( i in { submit: true, reset: true } ) {
+	Expr.pseudos[ i ] = createButtonPseudo( i );
+}
+
+// Easy API for creating new setFilters
+function setFilters() {}
+setFilters.prototype = Expr.filters = Expr.pseudos;
+Expr.setFilters = new setFilters();
+
+function tokenize( selector, parseOnly ) {
+	var matched, match, tokens, type,
+		soFar, groups, preFilters,
+		cached = tokenCache[ selector + " " ];
+
+	if ( cached ) {
+		return parseOnly ? 0 : cached.slice( 0 );
+	}
+
+	soFar = selector;
+	groups = [];
+	preFilters = Expr.preFilter;
+
+	while ( soFar ) {
+
+		// Comma and first run
+		if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
+			if ( match ) {
+
+				// Don't consume trailing commas as valid
+				soFar = soFar.slice( match[ 0 ].length ) || soFar;
+			}
+			groups.push( ( tokens = [] ) );
+		}
+
+		matched = false;
+
+		// Combinators
+		if ( ( match = rleadingCombinator.exec( soFar ) ) ) {
+			matched = match.shift();
+			tokens.push( {
+				value: matched,
+
+				// Cast descendant combinators to space
+				type: match[ 0 ].replace( rtrimCSS, " " )
+			} );
+			soFar = soFar.slice( matched.length );
+		}
+
+		// Filters
+		for ( type in Expr.filter ) {
+			if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
+				( match = preFilters[ type ]( match ) ) ) ) {
+				matched = match.shift();
+				tokens.push( {
+					value: matched,
+					type: type,
+					matches: match
+				} );
+				soFar = soFar.slice( matched.length );
+			}
+		}
+
+		if ( !matched ) {
+			break;
+		}
+	}
+
+	// Return the length of the invalid excess
+	// if we're just parsing
+	// Otherwise, throw an error or return tokens
+	if ( parseOnly ) {
+		return soFar.length;
+	}
+
+	return soFar ?
+		find.error( selector ) :
+
+		// Cache the tokens
+		tokenCache( selector, groups ).slice( 0 );
+}
+
+function toSelector( tokens ) {
+	var i = 0,
+		len = tokens.length,
+		selector = "";
+	for ( ; i < len; i++ ) {
+		selector += tokens[ i ].value;
+	}
+	return selector;
+}
+
+function addCombinator( matcher, combinator, base ) {
+	var dir = combinator.dir,
+		skip = combinator.next,
+		key = skip || dir,
+		checkNonElements = base && key === "parentNode",
+		doneName = done++;
+
+	return combinator.first ?
+
+		// Check against closest ancestor/preceding element
+		function( elem, context, xml ) {
+			while ( ( elem = elem[ dir ] ) ) {
+				if ( elem.nodeType === 1 || checkNonElements ) {
+					return matcher( elem, context, xml );
+				}
+			}
+			return false;
+		} :
+
+		// Check against all ancestor/preceding elements
+		function( elem, context, xml ) {
+			var oldCache, outerCache,
+				newCache = [ dirruns, doneName ];
+
+			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
+			if ( xml ) {
+				while ( ( elem = elem[ dir ] ) ) {
+					if ( elem.nodeType === 1 || checkNonElements ) {
+						if ( matcher( elem, context, xml ) ) {
+							return true;
+						}
+					}
+				}
+			} else {
+				while ( ( elem = elem[ dir ] ) ) {
+					if ( elem.nodeType === 1 || checkNonElements ) {
+						outerCache = elem[ expando ] || ( elem[ expando ] = {} );
+
+						if ( skip && nodeName( elem, skip ) ) {
+							elem = elem[ dir ] || elem;
+						} else if ( ( oldCache = outerCache[ key ] ) &&
+							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
+
+							// Assign to newCache so results back-propagate to previous elements
+							return ( newCache[ 2 ] = oldCache[ 2 ] );
+						} else {
+
+							// Reuse newcache so results back-propagate to previous elements
+							outerCache[ key ] = newCache;
+
+							// A match means we're done; a fail means we have to keep checking
+							if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
+								return true;
+							}
+						}
+					}
+				}
+			}
+			return false;
+		};
+}
+
+function elementMatcher( matchers ) {
+	return matchers.length > 1 ?
+		function( elem, context, xml ) {
+			var i = matchers.length;
+			while ( i-- ) {
+				if ( !matchers[ i ]( elem, context, xml ) ) {
+					return false;
+				}
+			}
+			return true;
+		} :
+		matchers[ 0 ];
+}
+
+function multipleContexts( selector, contexts, results ) {
+	var i = 0,
+		len = contexts.length;
+	for ( ; i < len; i++ ) {
+		find( selector, contexts[ i ], results );
+	}
+	return results;
+}
+
+function condense( unmatched, map, filter, context, xml ) {
+	var elem,
+		newUnmatched = [],
+		i = 0,
+		len = unmatched.length,
+		mapped = map != null;
+
+	for ( ; i < len; i++ ) {
+		if ( ( elem = unmatched[ i ] ) ) {
+			if ( !filter || filter( elem, context, xml ) ) {
+				newUnmatched.push( elem );
+				if ( mapped ) {
+					map.push( i );
+				}
+			}
+		}
+	}
+
+	return newUnmatched;
+}
+
+function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
+	if ( postFilter && !postFilter[ expando ] ) {
+		postFilter = setMatcher( postFilter );
+	}
+	if ( postFinder && !postFinder[ expando ] ) {
+		postFinder = setMatcher( postFinder, postSelector );
+	}
+	return markFunction( function( seed, results, context, xml ) {
+		var temp, i, elem, matcherOut,
+			preMap = [],
+			postMap = [],
+			preexisting = results.length,
+
+			// Get initial elements from seed or context
+			elems = seed ||
+				multipleContexts( selector || "*",
+					context.nodeType ? [ context ] : context, [] ),
+
+			// Prefilter to get matcher input, preserving a map for seed-results synchronization
+			matcherIn = preFilter && ( seed || !selector ) ?
+				condense( elems, preMap, preFilter, context, xml ) :
+				elems;
+
+		if ( matcher ) {
+
+			// If we have a postFinder, or filtered seed, or non-seed postFilter
+			// or preexisting results,
+			matcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
+
+				// ...intermediate processing is necessary
+				[] :
+
+				// ...otherwise use results directly
+				results;
+
+			// Find primary matches
+			matcher( matcherIn, matcherOut, context, xml );
+		} else {
+			matcherOut = matcherIn;
+		}
+
+		// Apply postFilter
+		if ( postFilter ) {
+			temp = condense( matcherOut, postMap );
+			postFilter( temp, [], context, xml );
+
+			// Un-match failing elements by moving them back to matcherIn
+			i = temp.length;
+			while ( i-- ) {
+				if ( ( elem = temp[ i ] ) ) {
+					matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
+				}
+			}
+		}
+
+		if ( seed ) {
+			if ( postFinder || preFilter ) {
+				if ( postFinder ) {
+
+					// Get the final matcherOut by condensing this intermediate into postFinder contexts
+					temp = [];
+					i = matcherOut.length;
+					while ( i-- ) {
+						if ( ( elem = matcherOut[ i ] ) ) {
+
+							// Restore matcherIn since elem is not yet a final match
+							temp.push( ( matcherIn[ i ] = elem ) );
+						}
+					}
+					postFinder( null, ( matcherOut = [] ), temp, xml );
+				}
+
+				// Move matched elements from seed to results to keep them synchronized
+				i = matcherOut.length;
+				while ( i-- ) {
+					if ( ( elem = matcherOut[ i ] ) &&
+						( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) {
+
+						seed[ temp ] = !( results[ temp ] = elem );
+					}
+				}
+			}
+
+		// Add elements to results, through postFinder if defined
+		} else {
+			matcherOut = condense(
+				matcherOut === results ?
+					matcherOut.splice( preexisting, matcherOut.length ) :
+					matcherOut
+			);
+			if ( postFinder ) {
+				postFinder( null, results, matcherOut, xml );
+			} else {
+				push.apply( results, matcherOut );
+			}
+		}
+	} );
+}
+
+function matcherFromTokens( tokens ) {
+	var checkContext, matcher, j,
+		len = tokens.length,
+		leadingRelative = Expr.relative[ tokens[ 0 ].type ],
+		implicitRelative = leadingRelative || Expr.relative[ " " ],
+		i = leadingRelative ? 1 : 0,
+
+		// The foundational matcher ensures that elements are reachable from top-level context(s)
+		matchContext = addCombinator( function( elem ) {
+			return elem === checkContext;
+		}, implicitRelative, true ),
+		matchAnyContext = addCombinator( function( elem ) {
+			return indexOf.call( checkContext, elem ) > -1;
+		}, implicitRelative, true ),
+		matchers = [ function( elem, context, xml ) {
+
+			// Support: IE 11+, Edge 17 - 18+
+			// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+			// two documents; shallow comparisons work.
+			// eslint-disable-next-line eqeqeq
+			var ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || (
+				( checkContext = context ).nodeType ?
+					matchContext( elem, context, xml ) :
+					matchAnyContext( elem, context, xml ) );
+
+			// Avoid hanging onto element
+			// (see https://github.com/jquery/sizzle/issues/299)
+			checkContext = null;
+			return ret;
+		} ];
+
+	for ( ; i < len; i++ ) {
+		if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
+			matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
+		} else {
+			matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
+
+			// Return special upon seeing a positional matcher
+			if ( matcher[ expando ] ) {
+
+				// Find the next relative operator (if any) for proper handling
+				j = ++i;
+				for ( ; j < len; j++ ) {
+					if ( Expr.relative[ tokens[ j ].type ] ) {
+						break;
+					}
+				}
+				return setMatcher(
+					i > 1 && elementMatcher( matchers ),
+					i > 1 && toSelector(
+
+						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
+						tokens.slice( 0, i - 1 )
+							.concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
+					).replace( rtrimCSS, "$1" ),
+					matcher,
+					i < j && matcherFromTokens( tokens.slice( i, j ) ),
+					j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
+					j < len && toSelector( tokens )
+				);
+			}
+			matchers.push( matcher );
+		}
+	}
+
+	return elementMatcher( matchers );
+}
+
+function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
+	var bySet = setMatchers.length > 0,
+		byElement = elementMatchers.length > 0,
+		superMatcher = function( seed, context, xml, results, outermost ) {
+			var elem, j, matcher,
+				matchedCount = 0,
+				i = "0",
+				unmatched = seed && [],
+				setMatched = [],
+				contextBackup = outermostContext,
+
+				// We must always have either seed elements or outermost context
+				elems = seed || byElement && Expr.find.TAG( "*", outermost ),
+
+				// Use integer dirruns iff this is the outermost matcher
+				dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
+				len = elems.length;
+
+			if ( outermost ) {
+
+				// Support: IE 11+, Edge 17 - 18+
+				// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+				// two documents; shallow comparisons work.
+				// eslint-disable-next-line eqeqeq
+				outermostContext = context == document || context || outermost;
+			}
+
+			// Add elements passing elementMatchers directly to results
+			// Support: iOS <=7 - 9 only
+			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching
+			// elements by id. (see trac-14142)
+			for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
+				if ( byElement && elem ) {
+					j = 0;
+
+					// Support: IE 11+, Edge 17 - 18+
+					// IE/Edge sometimes throw a "Permission denied" error when strict-comparing
+					// two documents; shallow comparisons work.
+					// eslint-disable-next-line eqeqeq
+					if ( !context && elem.ownerDocument != document ) {
+						setDocument( elem );
+						xml = !documentIsHTML;
+					}
+					while ( ( matcher = elementMatchers[ j++ ] ) ) {
+						if ( matcher( elem, context || document, xml ) ) {
+							push.call( results, elem );
+							break;
+						}
+					}
+					if ( outermost ) {
+						dirruns = dirrunsUnique;
+					}
+				}
+
+				// Track unmatched elements for set filters
+				if ( bySet ) {
+
+					// They will have gone through all possible matchers
+					if ( ( elem = !matcher && elem ) ) {
+						matchedCount--;
+					}
+
+					// Lengthen the array for every element, matched or not
+					if ( seed ) {
+						unmatched.push( elem );
+					}
+				}
+			}
+
+			// `i` is now the count of elements visited above, and adding it to `matchedCount`
+			// makes the latter nonnegative.
+			matchedCount += i;
+
+			// Apply set filters to unmatched elements
+			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
+			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
+			// no element matchers and no seed.
+			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
+			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
+			// numerically zero.
+			if ( bySet && i !== matchedCount ) {
+				j = 0;
+				while ( ( matcher = setMatchers[ j++ ] ) ) {
+					matcher( unmatched, setMatched, context, xml );
+				}
+
+				if ( seed ) {
+
+					// Reintegrate element matches to eliminate the need for sorting
+					if ( matchedCount > 0 ) {
+						while ( i-- ) {
+							if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
+								setMatched[ i ] = pop.call( results );
+							}
+						}
+					}
+
+					// Discard index placeholder values to get only actual matches
+					setMatched = condense( setMatched );
+				}
+
+				// Add matches to results
+				push.apply( results, setMatched );
+
+				// Seedless set matches succeeding multiple successful matchers stipulate sorting
+				if ( outermost && !seed && setMatched.length > 0 &&
+					( matchedCount + setMatchers.length ) > 1 ) {
+
+					jQuery.uniqueSort( results );
+				}
+			}
+
+			// Override manipulation of globals by nested matchers
+			if ( outermost ) {
+				dirruns = dirrunsUnique;
+				outermostContext = contextBackup;
+			}
+
+			return unmatched;
+		};
+
+	return bySet ?
+		markFunction( superMatcher ) :
+		superMatcher;
+}
+
+function compile( selector, match /* Internal Use Only */ ) {
+	var i,
+		setMatchers = [],
+		elementMatchers = [],
+		cached = compilerCache[ selector + " " ];
+
+	if ( !cached ) {
+
+		// Generate a function of recursive functions that can be used to check each element
+		if ( !match ) {
+			match = tokenize( selector );
+		}
+		i = match.length;
+		while ( i-- ) {
+			cached = matcherFromTokens( match[ i ] );
+			if ( cached[ expando ] ) {
+				setMatchers.push( cached );
+			} else {
+				elementMatchers.push( cached );
+			}
+		}
+
+		// Cache the compiled function
+		cached = compilerCache( selector,
+			matcherFromGroupMatchers( elementMatchers, setMatchers ) );
+
+		// Save selector and tokenization
+		cached.selector = selector;
+	}
+	return cached;
+}
+
+/**
+ * A low-level selection function that works with jQuery's compiled
+ *  selector functions
+ * @param {String|Function} selector A selector or a pre-compiled
+ *  selector function built with jQuery selector compile
+ * @param {Element} context
+ * @param {Array} [results]
+ * @param {Array} [seed] A set of elements to match against
+ */
+function select( selector, context, results, seed ) {
+	var i, tokens, token, type, find,
+		compiled = typeof selector === "function" && selector,
+		match = !seed && tokenize( ( selector = compiled.selector || selector ) );
+
+	results = results || [];
+
+	// Try to minimize operations if there is only one selector in the list and no seed
+	// (the latter of which guarantees us context)
+	if ( match.length === 1 ) {
+
+		// Reduce context if the leading compound selector is an ID
+		tokens = match[ 0 ] = match[ 0 ].slice( 0 );
+		if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
+				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
+
+			context = ( Expr.find.ID(
+				token.matches[ 0 ].replace( runescape, funescape ),
+				context
+			) || [] )[ 0 ];
+			if ( !context ) {
+				return results;
+
+			// Precompiled matchers will still verify ancestry, so step up a level
+			} else if ( compiled ) {
+				context = context.parentNode;
+			}
+
+			selector = selector.slice( tokens.shift().value.length );
+		}
+
+		// Fetch a seed set for right-to-left matching
+		i = matchExpr.needsContext.test( selector ) ? 0 : tokens.length;
+		while ( i-- ) {
+			token = tokens[ i ];
+
+			// Abort if we hit a combinator
+			if ( Expr.relative[ ( type = token.type ) ] ) {
+				break;
+			}
+			if ( ( find = Expr.find[ type ] ) ) {
+
+				// Search, expanding context for leading sibling combinators
+				if ( ( seed = find(
+					token.matches[ 0 ].replace( runescape, funescape ),
+					rsibling.test( tokens[ 0 ].type ) &&
+						testContext( context.parentNode ) || context
+				) ) ) {
+
+					// If seed is empty or no tokens remain, we can return early
+					tokens.splice( i, 1 );
+					selector = seed.length && toSelector( tokens );
+					if ( !selector ) {
+						push.apply( results, seed );
+						return results;
+					}
+
+					break;
+				}
+			}
+		}
+	}
+
+	// Compile and execute a filtering function if one is not provided
+	// Provide `match` to avoid retokenization if we modified the selector above
+	( compiled || compile( selector, match ) )(
+		seed,
+		context,
+		!documentIsHTML,
+		results,
+		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
+	);
+	return results;
+}
+
+// One-time assignments
+
+// Support: Android <=4.0 - 4.1+
+// Sort stability
+support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
+
+// Initialize against the default document
+setDocument();
+
+// Support: Android <=4.0 - 4.1+
+// Detached nodes confoundingly follow *each other*
+support.sortDetached = assert( function( el ) {
+
+	// Should return 1, but returns 4 (following)
+	return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
+} );
+
+jQuery.find = find;
+
+// Deprecated
+jQuery.expr[ ":" ] = jQuery.expr.pseudos;
+jQuery.unique = jQuery.uniqueSort;
+
+// These have always been private, but they used to be documented as part of
+// Sizzle so let's maintain them for now for backwards compatibility purposes.
+find.compile = compile;
+find.select = select;
+find.setDocument = setDocument;
+find.tokenize = tokenize;
+
+find.escape = jQuery.escapeSelector;
+find.getText = jQuery.text;
+find.isXML = jQuery.isXMLDoc;
+find.selectors = jQuery.expr;
+find.support = jQuery.support;
+find.uniqueSort = jQuery.uniqueSort;
+
+	/* eslint-enable */
+
+} )();
+
+
+var dir = function( elem, dir, until ) {
+	var matched = [],
+		truncate = until !== undefined;
+
+	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
+		if ( elem.nodeType === 1 ) {
+			if ( truncate && jQuery( elem ).is( until ) ) {
+				break;
+			}
+			matched.push( elem );
+		}
+	}
+	return matched;
+};
+
+
+var siblings = function( n, elem ) {
+	var matched = [];
+
+	for ( ; n; n = n.nextSibling ) {
+		if ( n.nodeType === 1 && n !== elem ) {
+			matched.push( n );
+		}
+	}
+
+	return matched;
+};
+
+
+var rneedsContext = jQuery.expr.match.needsContext;
+
+var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
+
+
+
+// Implement the identical functionality for filter and not
+function winnow( elements, qualifier, not ) {
+	if ( isFunction( qualifier ) ) {
+		return jQuery.grep( elements, function( elem, i ) {
+			return !!qualifier.call( elem, i, elem ) !== not;
+		} );
+	}
+
+	// Single element
+	if ( qualifier.nodeType ) {
+		return jQuery.grep( elements, function( elem ) {
+			return ( elem === qualifier ) !== not;
+		} );
+	}
+
+	// Arraylike of elements (jQuery, arguments, Array)
+	if ( typeof qualifier !== "string" ) {
+		return jQuery.grep( elements, function( elem ) {
+			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
+		} );
+	}
+
+	// Filtered directly for both simple and complex selectors
+	return jQuery.filter( qualifier, elements, not );
+}
+
+jQuery.filter = function( expr, elems, not ) {
+	var elem = elems[ 0 ];
+
+	if ( not ) {
+		expr = ":not(" + expr + ")";
+	}
+
+	if ( elems.length === 1 && elem.nodeType === 1 ) {
+		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
+	}
+
+	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
+		return elem.nodeType === 1;
+	} ) );
+};
+
+jQuery.fn.extend( {
+	find: function( selector ) {
+		var i, ret,
+			len = this.length,
+			self = this;
+
+		if ( typeof selector !== "string" ) {
+			return this.pushStack( jQuery( selector ).filter( function() {
+				for ( i = 0; i < len; i++ ) {
+					if ( jQuery.contains( self[ i ], this ) ) {
+						return true;
+					}
+				}
+			} ) );
+		}
+
+		ret = this.pushStack( [] );
+
+		for ( i = 0; i < len; i++ ) {
+			jQuery.find( selector, self[ i ], ret );
+		}
+
+		return len > 1 ? jQuery.uniqueSort( ret ) : ret;
+	},
+	filter: function( selector ) {
+		return this.pushStack( winnow( this, selector || [], false ) );
+	},
+	not: function( selector ) {
+		return this.pushStack( winnow( this, selector || [], true ) );
+	},
+	is: function( selector ) {
+		return !!winnow(
+			this,
+
+			// If this is a positional/relative selector, check membership in the returned set
+			// so $("p:first").is("p:last") won't return true for a doc with two "p".
+			typeof selector === "string" && rneedsContext.test( selector ) ?
+				jQuery( selector ) :
+				selector || [],
+			false
+		).length;
+	}
+} );
+
+
+// Initialize a jQuery object
+
+
+// A central reference to the root jQuery(document)
+var rootjQuery,
+
+	// A simple way to check for HTML strings
+	// Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521)
+	// Strict HTML recognition (trac-11290: must start with <)
+	// Shortcut simple #id case for speed
+	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
+
+	init = jQuery.fn.init = function( selector, context, root ) {
+		var match, elem;
+
+		// HANDLE: $(""), $(null), $(undefined), $(false)
+		if ( !selector ) {
+			return this;
+		}
+
+		// Method init() accepts an alternate rootjQuery
+		// so migrate can support jQuery.sub (gh-2101)
+		root = root || rootjQuery;
+
+		// Handle HTML strings
+		if ( typeof selector === "string" ) {
+			if ( selector[ 0 ] === "<" &&
+				selector[ selector.length - 1 ] === ">" &&
+				selector.length >= 3 ) {
+
+				// Assume that strings that start and end with <> are HTML and skip the regex check
+				match = [ null, selector, null ];
+
+			} else {
+				match = rquickExpr.exec( selector );
+			}
+
+			// Match html or make sure no context is specified for #id
+			if ( match && ( match[ 1 ] || !context ) ) {
+
+				// HANDLE: $(html) -> $(array)
+				if ( match[ 1 ] ) {
+					context = context instanceof jQuery ? context[ 0 ] : context;
+
+					// Option to run scripts is true for back-compat
+					// Intentionally let the error be thrown if parseHTML is not present
+					jQuery.merge( this, jQuery.parseHTML(
+						match[ 1 ],
+						context && context.nodeType ? context.ownerDocument || context : document,
+						true
+					) );
+
+					// HANDLE: $(html, props)
+					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
+						for ( match in context ) {
+
+							// Properties of context are called as methods if possible
+							if ( isFunction( this[ match ] ) ) {
+								this[ match ]( context[ match ] );
+
+							// ...and otherwise set as attributes
+							} else {
+								this.attr( match, context[ match ] );
+							}
+						}
+					}
+
+					return this;
+
+				// HANDLE: $(#id)
+				} else {
+					elem = document.getElementById( match[ 2 ] );
+
+					if ( elem ) {
+
+						// Inject the element directly into the jQuery object
+						this[ 0 ] = elem;
+						this.length = 1;
+					}
+					return this;
+				}
+
+			// HANDLE: $(expr, $(...))
+			} else if ( !context || context.jquery ) {
+				return ( context || root ).find( selector );
+
+			// HANDLE: $(expr, context)
+			// (which is just equivalent to: $(context).find(expr)
+			} else {
+				return this.constructor( context ).find( selector );
+			}
+
+		// HANDLE: $(DOMElement)
+		} else if ( selector.nodeType ) {
+			this[ 0 ] = selector;
+			this.length = 1;
+			return this;
+
+		// HANDLE: $(function)
+		// Shortcut for document ready
+		} else if ( isFunction( selector ) ) {
+			return root.ready !== undefined ?
+				root.ready( selector ) :
+
+				// Execute immediately if ready is not present
+				selector( jQuery );
+		}
+
+		return jQuery.makeArray( selector, this );
+	};
+
+// Give the init function the jQuery prototype for later instantiation
+init.prototype = jQuery.fn;
+
+// Initialize central reference
+rootjQuery = jQuery( document );
+
+
+var rparentsprev = /^(?:parents|prev(?:Until|All))/,
+
+	// Methods guaranteed to produce a unique set when starting from a unique set
+	guaranteedUnique = {
+		children: true,
+		contents: true,
+		next: true,
+		prev: true
+	};
+
+jQuery.fn.extend( {
+	has: function( target ) {
+		var targets = jQuery( target, this ),
+			l = targets.length;
+
+		return this.filter( function() {
+			var i = 0;
+			for ( ; i < l; i++ ) {
+				if ( jQuery.contains( this, targets[ i ] ) ) {
+					return true;
+				}
+			}
+		} );
+	},
+
+	closest: function( selectors, context ) {
+		var cur,
+			i = 0,
+			l = this.length,
+			matched = [],
+			targets = typeof selectors !== "string" && jQuery( selectors );
+
+		// Positional selectors never match, since there's no _selection_ context
+		if ( !rneedsContext.test( selectors ) ) {
+			for ( ; i < l; i++ ) {
+				for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
+
+					// Always skip document fragments
+					if ( cur.nodeType < 11 && ( targets ?
+						targets.index( cur ) > -1 :
+
+						// Don't pass non-elements to jQuery#find
+						cur.nodeType === 1 &&
+							jQuery.find.matchesSelector( cur, selectors ) ) ) {
+
+						matched.push( cur );
+						break;
+					}
+				}
+			}
+		}
+
+		return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
+	},
+
+	// Determine the position of an element within the set
+	index: function( elem ) {
+
+		// No argument, return index in parent
+		if ( !elem ) {
+			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
+		}
+
+		// Index in selector
+		if ( typeof elem === "string" ) {
+			return indexOf.call( jQuery( elem ), this[ 0 ] );
+		}
+
+		// Locate the position of the desired element
+		return indexOf.call( this,
+
+			// If it receives a jQuery object, the first element is used
+			elem.jquery ? elem[ 0 ] : elem
+		);
+	},
+
+	add: function( selector, context ) {
+		return this.pushStack(
+			jQuery.uniqueSort(
+				jQuery.merge( this.get(), jQuery( selector, context ) )
+			)
+		);
+	},
+
+	addBack: function( selector ) {
+		return this.add( selector == null ?
+			this.prevObject : this.prevObject.filter( selector )
+		);
+	}
+} );
+
+function sibling( cur, dir ) {
+	while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
+	return cur;
+}
+
+jQuery.each( {
+	parent: function( elem ) {
+		var parent = elem.parentNode;
+		return parent && parent.nodeType !== 11 ? parent : null;
+	},
+	parents: function( elem ) {
+		return dir( elem, "parentNode" );
+	},
+	parentsUntil: function( elem, _i, until ) {
+		return dir( elem, "parentNode", until );
+	},
+	next: function( elem ) {
+		return sibling( elem, "nextSibling" );
+	},
+	prev: function( elem ) {
+		return sibling( elem, "previousSibling" );
+	},
+	nextAll: function( elem ) {
+		return dir( elem, "nextSibling" );
+	},
+	prevAll: function( elem ) {
+		return dir( elem, "previousSibling" );
+	},
+	nextUntil: function( elem, _i, until ) {
+		return dir( elem, "nextSibling", until );
+	},
+	prevUntil: function( elem, _i, until ) {
+		return dir( elem, "previousSibling", until );
+	},
+	siblings: function( elem ) {
+		return siblings( ( elem.parentNode || {} ).firstChild, elem );
+	},
+	children: function( elem ) {
+		return siblings( elem.firstChild );
+	},
+	contents: function( elem ) {
+		if ( elem.contentDocument != null &&
+
+			// Support: IE 11+
+			// <object> elements with no `data` attribute has an object
+			// `contentDocument` with a `null` prototype.
+			getProto( elem.contentDocument ) ) {
+
+			return elem.contentDocument;
+		}
+
+		// Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
+		// Treat the template element as a regular one in browsers that
+		// don't support it.
+		if ( nodeName( elem, "template" ) ) {
+			elem = elem.content || elem;
+		}
+
+		return jQuery.merge( [], elem.childNodes );
+	}
+}, function( name, fn ) {
+	jQuery.fn[ name ] = function( until, selector ) {
+		var matched = jQuery.map( this, fn, until );
+
+		if ( name.slice( -5 ) !== "Until" ) {
+			selector = until;
+		}
+
+		if ( selector && typeof selector === "string" ) {
+			matched = jQuery.filter( selector, matched );
+		}
+
+		if ( this.length > 1 ) {
+
+			// Remove duplicates
+			if ( !guaranteedUnique[ name ] ) {
+				jQuery.uniqueSort( matched );
+			}
+
+			// Reverse order for parents* and prev-derivatives
+			if ( rparentsprev.test( name ) ) {
+				matched.reverse();
+			}
+		}
+
+		return this.pushStack( matched );
+	};
+} );
+var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
+
+
+
+// Convert String-formatted options into Object-formatted ones
+function createOptions( options ) {
+	var object = {};
+	jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
+		object[ flag ] = true;
+	} );
+	return object;
+}
+
+/*
+ * Create a callback list using the following parameters:
+ *
+ *	options: an optional list of space-separated options that will change how
+ *			the callback list behaves or a more traditional option object
+ *
+ * By default a callback list will act like an event callback list and can be
+ * "fired" multiple times.
+ *
+ * Possible options:
+ *
+ *	once:			will ensure the callback list can only be fired once (like a Deferred)
+ *
+ *	memory:			will keep track of previous values and will call any callback added
+ *					after the list has been fired right away with the latest "memorized"
+ *					values (like a Deferred)
+ *
+ *	unique:			will ensure a callback can only be added once (no duplicate in the list)
+ *
+ *	stopOnFalse:	interrupt callings when a callback returns false
+ *
+ */
+jQuery.Callbacks = function( options ) {
+
+	// Convert options from String-formatted to Object-formatted if needed
+	// (we check in cache first)
+	options = typeof options === "string" ?
+		createOptions( options ) :
+		jQuery.extend( {}, options );
+
+	var // Flag to know if list is currently firing
+		firing,
+
+		// Last fire value for non-forgettable lists
+		memory,
+
+		// Flag to know if list was already fired
+		fired,
+
+		// Flag to prevent firing
+		locked,
+
+		// Actual callback list
+		list = [],
+
+		// Queue of execution data for repeatable lists
+		queue = [],
+
+		// Index of currently firing callback (modified by add/remove as needed)
+		firingIndex = -1,
+
+		// Fire callbacks
+		fire = function() {
+
+			// Enforce single-firing
+			locked = locked || options.once;
+
+			// Execute callbacks for all pending executions,
+			// respecting firingIndex overrides and runtime changes
+			fired = firing = true;
+			for ( ; queue.length; firingIndex = -1 ) {
+				memory = queue.shift();
+				while ( ++firingIndex < list.length ) {
+
+					// Run callback and check for early termination
+					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
+						options.stopOnFalse ) {
+
+						// Jump to end and forget the data so .add doesn't re-fire
+						firingIndex = list.length;
+						memory = false;
+					}
+				}
+			}
+
+			// Forget the data if we're done with it
+			if ( !options.memory ) {
+				memory = false;
+			}
+
+			firing = false;
+
+			// Clean up if we're done firing for good
+			if ( locked ) {
+
+				// Keep an empty list if we have data for future add calls
+				if ( memory ) {
+					list = [];
+
+				// Otherwise, this object is spent
+				} else {
+					list = "";
+				}
+			}
+		},
+
+		// Actual Callbacks object
+		self = {
+
+			// Add a callback or a collection of callbacks to the list
+			add: function() {
+				if ( list ) {
+
+					// If we have memory from a past run, we should fire after adding
+					if ( memory && !firing ) {
+						firingIndex = list.length - 1;
+						queue.push( memory );
+					}
+
+					( function add( args ) {
+						jQuery.each( args, function( _, arg ) {
+							if ( isFunction( arg ) ) {
+								if ( !options.unique || !self.has( arg ) ) {
+									list.push( arg );
+								}
+							} else if ( arg && arg.length && toType( arg ) !== "string" ) {
+
+								// Inspect recursively
+								add( arg );
+							}
+						} );
+					} )( arguments );
+
+					if ( memory && !firing ) {
+						fire();
+					}
+				}
+				return this;
+			},
+
+			// Remove a callback from the list
+			remove: function() {
+				jQuery.each( arguments, function( _, arg ) {
+					var index;
+					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
+						list.splice( index, 1 );
+
+						// Handle firing indexes
+						if ( index <= firingIndex ) {
+							firingIndex--;
+						}
+					}
+				} );
+				return this;
+			},
+
+			// Check if a given callback is in the list.
+			// If no argument is given, return whether or not list has callbacks attached.
+			has: function( fn ) {
+				return fn ?
+					jQuery.inArray( fn, list ) > -1 :
+					list.length > 0;
+			},
+
+			// Remove all callbacks from the list
+			empty: function() {
+				if ( list ) {
+					list = [];
+				}
+				return this;
+			},
+
+			// Disable .fire and .add
+			// Abort any current/pending executions
+			// Clear all callbacks and values
+			disable: function() {
+				locked = queue = [];
+				list = memory = "";
+				return this;
+			},
+			disabled: function() {
+				return !list;
+			},
+
+			// Disable .fire
+			// Also disable .add unless we have memory (since it would have no effect)
+			// Abort any pending executions
+			lock: function() {
+				locked = queue = [];
+				if ( !memory && !firing ) {
+					list = memory = "";
+				}
+				return this;
+			},
+			locked: function() {
+				return !!locked;
+			},
+
+			// Call all callbacks with the given context and arguments
+			fireWith: function( context, args ) {
+				if ( !locked ) {
+					args = args || [];
+					args = [ context, args.slice ? args.slice() : args ];
+					queue.push( args );
+					if ( !firing ) {
+						fire();
+					}
+				}
+				return this;
+			},
+
+			// Call all the callbacks with the given arguments
+			fire: function() {
+				self.fireWith( this, arguments );
+				return this;
+			},
+
+			// To know if the callbacks have already been called at least once
+			fired: function() {
+				return !!fired;
+			}
+		};
+
+	return self;
+};
+
+
+function Identity( v ) {
+	return v;
+}
+function Thrower( ex ) {
+	throw ex;
+}
+
+function adoptValue( value, resolve, reject, noValue ) {
+	var method;
+
+	try {
+
+		// Check for promise aspect first to privilege synchronous behavior
+		if ( value && isFunction( ( method = value.promise ) ) ) {
+			method.call( value ).done( resolve ).fail( reject );
+
+		// Other thenables
+		} else if ( value && isFunction( ( method = value.then ) ) ) {
+			method.call( value, resolve, reject );
+
+		// Other non-thenables
+		} else {
+
+			// Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
+			// * false: [ value ].slice( 0 ) => resolve( value )
+			// * true: [ value ].slice( 1 ) => resolve()
+			resolve.apply( undefined, [ value ].slice( noValue ) );
+		}
+
+	// For Promises/A+, convert exceptions into rejections
+	// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
+	// Deferred#then to conditionally suppress rejection.
+	} catch ( value ) {
+
+		// Support: Android 4.0 only
+		// Strict mode functions invoked without .call/.apply get global-object context
+		reject.apply( undefined, [ value ] );
+	}
+}
+
+jQuery.extend( {
+
+	Deferred: function( func ) {
+		var tuples = [
+
+				// action, add listener, callbacks,
+				// ... .then handlers, argument index, [final state]
+				[ "notify", "progress", jQuery.Callbacks( "memory" ),
+					jQuery.Callbacks( "memory" ), 2 ],
+				[ "resolve", "done", jQuery.Callbacks( "once memory" ),
+					jQuery.Callbacks( "once memory" ), 0, "resolved" ],
+				[ "reject", "fail", jQuery.Callbacks( "once memory" ),
+					jQuery.Callbacks( "once memory" ), 1, "rejected" ]
+			],
+			state = "pending",
+			promise = {
+				state: function() {
+					return state;
+				},
+				always: function() {
+					deferred.done( arguments ).fail( arguments );
+					return this;
+				},
+				"catch": function( fn ) {
+					return promise.then( null, fn );
+				},
+
+				// Keep pipe for back-compat
+				pipe: function( /* fnDone, fnFail, fnProgress */ ) {
+					var fns = arguments;
+
+					return jQuery.Deferred( function( newDefer ) {
+						jQuery.each( tuples, function( _i, tuple ) {
+
+							// Map tuples (progress, done, fail) to arguments (done, fail, progress)
+							var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
+
+							// deferred.progress(function() { bind to newDefer or newDefer.notify })
+							// deferred.done(function() { bind to newDefer or newDefer.resolve })
+							// deferred.fail(function() { bind to newDefer or newDefer.reject })
+							deferred[ tuple[ 1 ] ]( function() {
+								var returned = fn && fn.apply( this, arguments );
+								if ( returned && isFunction( returned.promise ) ) {
+									returned.promise()
+										.progress( newDefer.notify )
+										.done( newDefer.resolve )
+										.fail( newDefer.reject );
+								} else {
+									newDefer[ tuple[ 0 ] + "With" ](
+										this,
+										fn ? [ returned ] : arguments
+									);
+								}
+							} );
+						} );
+						fns = null;
+					} ).promise();
+				},
+				then: function( onFulfilled, onRejected, onProgress ) {
+					var maxDepth = 0;
+					function resolve( depth, deferred, handler, special ) {
+						return function() {
+							var that = this,
+								args = arguments,
+								mightThrow = function() {
+									var returned, then;
+
+									// Support: Promises/A+ section 2.3.3.3.3
+									// https://promisesaplus.com/#point-59
+									// Ignore double-resolution attempts
+									if ( depth < maxDepth ) {
+										return;
+									}
+
+									returned = handler.apply( that, args );
+
+									// Support: Promises/A+ section 2.3.1
+									// https://promisesaplus.com/#point-48
+									if ( returned === deferred.promise() ) {
+										throw new TypeError( "Thenable self-resolution" );
+									}
+
+									// Support: Promises/A+ sections 2.3.3.1, 3.5
+									// https://promisesaplus.com/#point-54
+									// https://promisesaplus.com/#point-75
+									// Retrieve `then` only once
+									then = returned &&
+
+										// Support: Promises/A+ section 2.3.4
+										// https://promisesaplus.com/#point-64
+										// Only check objects and functions for thenability
+										( typeof returned === "object" ||
+											typeof returned === "function" ) &&
+										returned.then;
+
+									// Handle a returned thenable
+									if ( isFunction( then ) ) {
+
+										// Special processors (notify) just wait for resolution
+										if ( special ) {
+											then.call(
+												returned,
+												resolve( maxDepth, deferred, Identity, special ),
+												resolve( maxDepth, deferred, Thrower, special )
+											);
+
+										// Normal processors (resolve) also hook into progress
+										} else {
+
+											// ...and disregard older resolution values
+											maxDepth++;
+
+											then.call(
+												returned,
+												resolve( maxDepth, deferred, Identity, special ),
+												resolve( maxDepth, deferred, Thrower, special ),
+												resolve( maxDepth, deferred, Identity,
+													deferred.notifyWith )
+											);
+										}
+
+									// Handle all other returned values
+									} else {
+
+										// Only substitute handlers pass on context
+										// and multiple values (non-spec behavior)
+										if ( handler !== Identity ) {
+											that = undefined;
+											args = [ returned ];
+										}
+
+										// Process the value(s)
+										// Default process is resolve
+										( special || deferred.resolveWith )( that, args );
+									}
+								},
+
+								// Only normal processors (resolve) catch and reject exceptions
+								process = special ?
+									mightThrow :
+									function() {
+										try {
+											mightThrow();
+										} catch ( e ) {
+
+											if ( jQuery.Deferred.exceptionHook ) {
+												jQuery.Deferred.exceptionHook( e,
+													process.error );
+											}
+
+											// Support: Promises/A+ section 2.3.3.3.4.1
+											// https://promisesaplus.com/#point-61
+											// Ignore post-resolution exceptions
+											if ( depth + 1 >= maxDepth ) {
+
+												// Only substitute handlers pass on context
+												// and multiple values (non-spec behavior)
+												if ( handler !== Thrower ) {
+													that = undefined;
+													args = [ e ];
+												}
+
+												deferred.rejectWith( that, args );
+											}
+										}
+									};
+
+							// Support: Promises/A+ section 2.3.3.3.1
+							// https://promisesaplus.com/#point-57
+							// Re-resolve promises immediately to dodge false rejection from
+							// subsequent errors
+							if ( depth ) {
+								process();
+							} else {
+
+								// Call an optional hook to record the error, in case of exception
+								// since it's otherwise lost when execution goes async
+								if ( jQuery.Deferred.getErrorHook ) {
+									process.error = jQuery.Deferred.getErrorHook();
+
+								// The deprecated alias of the above. While the name suggests
+								// returning the stack, not an error instance, jQuery just passes
+								// it directly to `console.warn` so both will work; an instance
+								// just better cooperates with source maps.
+								} else if ( jQuery.Deferred.getStackHook ) {
+									process.error = jQuery.Deferred.getStackHook();
+								}
+								window.setTimeout( process );
+							}
+						};
+					}
+
+					return jQuery.Deferred( function( newDefer ) {
+
+						// progress_handlers.add( ... )
+						tuples[ 0 ][ 3 ].add(
+							resolve(
+								0,
+								newDefer,
+								isFunction( onProgress ) ?
+									onProgress :
+									Identity,
+								newDefer.notifyWith
+							)
+						);
+
+						// fulfilled_handlers.add( ... )
+						tuples[ 1 ][ 3 ].add(
+							resolve(
+								0,
+								newDefer,
+								isFunction( onFulfilled ) ?
+									onFulfilled :
+									Identity
+							)
+						);
+
+						// rejected_handlers.add( ... )
+						tuples[ 2 ][ 3 ].add(
+							resolve(
+								0,
+								newDefer,
+								isFunction( onRejected ) ?
+									onRejected :
+									Thrower
+							)
+						);
+					} ).promise();
+				},
+
+				// Get a promise for this deferred
+				// If obj is provided, the promise aspect is added to the object
+				promise: function( obj ) {
+					return obj != null ? jQuery.extend( obj, promise ) : promise;
+				}
+			},
+			deferred = {};
+
+		// Add list-specific methods
+		jQuery.each( tuples, function( i, tuple ) {
+			var list = tuple[ 2 ],
+				stateString = tuple[ 5 ];
+
+			// promise.progress = list.add
+			// promise.done = list.add
+			// promise.fail = list.add
+			promise[ tuple[ 1 ] ] = list.add;
+
+			// Handle state
+			if ( stateString ) {
+				list.add(
+					function() {
+
+						// state = "resolved" (i.e., fulfilled)
+						// state = "rejected"
+						state = stateString;
+					},
+
+					// rejected_callbacks.disable
+					// fulfilled_callbacks.disable
+					tuples[ 3 - i ][ 2 ].disable,
+
+					// rejected_handlers.disable
+					// fulfilled_handlers.disable
+					tuples[ 3 - i ][ 3 ].disable,
+
+					// progress_callbacks.lock
+					tuples[ 0 ][ 2 ].lock,
+
+					// progress_handlers.lock
+					tuples[ 0 ][ 3 ].lock
+				);
+			}
+
+			// progress_handlers.fire
+			// fulfilled_handlers.fire
+			// rejected_handlers.fire
+			list.add( tuple[ 3 ].fire );
+
+			// deferred.notify = function() { deferred.notifyWith(...) }
+			// deferred.resolve = function() { deferred.resolveWith(...) }
+			// deferred.reject = function() { deferred.rejectWith(...) }
+			deferred[ tuple[ 0 ] ] = function() {
+				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
+				return this;
+			};
+
+			// deferred.notifyWith = list.fireWith
+			// deferred.resolveWith = list.fireWith
+			// deferred.rejectWith = list.fireWith
+			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
+		} );
+
+		// Make the deferred a promise
+		promise.promise( deferred );
+
+		// Call given func if any
+		if ( func ) {
+			func.call( deferred, deferred );
+		}
+
+		// All done!
+		return deferred;
+	},
+
+	// Deferred helper
+	when: function( singleValue ) {
+		var
+
+			// count of uncompleted subordinates
+			remaining = arguments.length,
+
+			// count of unprocessed arguments
+			i = remaining,
+
+			// subordinate fulfillment data
+			resolveContexts = Array( i ),
+			resolveValues = slice.call( arguments ),
+
+			// the primary Deferred
+			primary = jQuery.Deferred(),
+
+			// subordinate callback factory
+			updateFunc = function( i ) {
+				return function( value ) {
+					resolveContexts[ i ] = this;
+					resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
+					if ( !( --remaining ) ) {
+						primary.resolveWith( resolveContexts, resolveValues );
+					}
+				};
+			};
+
+		// Single- and empty arguments are adopted like Promise.resolve
+		if ( remaining <= 1 ) {
+			adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,
+				!remaining );
+
+			// Use .then() to unwrap secondary thenables (cf. gh-3000)
+			if ( primary.state() === "pending" ||
+				isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
+
+				return primary.then();
+			}
+		}
+
+		// Multiple arguments are aggregated like Promise.all array elements
+		while ( i-- ) {
+			adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );
+		}
+
+		return primary.promise();
+	}
+} );
+
+
+// These usually indicate a programmer mistake during development,
+// warn about them ASAP rather than swallowing them by default.
+var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
+
+// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error
+// captured before the async barrier to get the original error cause
+// which may otherwise be hidden.
+jQuery.Deferred.exceptionHook = function( error, asyncError ) {
+
+	// Support: IE 8 - 9 only
+	// Console exists when dev tools are open, which can happen at any time
+	if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
+		window.console.warn( "jQuery.Deferred exception: " + error.message,
+			error.stack, asyncError );
+	}
+};
+
+
+
+
+jQuery.readyException = function( error ) {
+	window.setTimeout( function() {
+		throw error;
+	} );
+};
+
+
+
+
+// The deferred used on DOM ready
+var readyList = jQuery.Deferred();
+
+jQuery.fn.ready = function( fn ) {
+
+	readyList
+		.then( fn )
+
+		// Wrap jQuery.readyException in a function so that the lookup
+		// happens at the time of error handling instead of callback
+		// registration.
+		.catch( function( error ) {
+			jQuery.readyException( error );
+		} );
+
+	return this;
+};
+
+jQuery.extend( {
+
+	// Is the DOM ready to be used? Set to true once it occurs.
+	isReady: false,
+
+	// A counter to track how many items to wait for before
+	// the ready event fires. See trac-6781
+	readyWait: 1,
+
+	// Handle when the DOM is ready
+	ready: function( wait ) {
+
+		// Abort if there are pending holds or we're already ready
+		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
+			return;
+		}
+
+		// Remember that the DOM is ready
+		jQuery.isReady = true;
+
+		// If a normal DOM Ready event fired, decrement, and wait if need be
+		if ( wait !== true && --jQuery.readyWait > 0 ) {
+			return;
+		}
+
+		// If there are functions bound, to execute
+		readyList.resolveWith( document, [ jQuery ] );
+	}
+} );
+
+jQuery.ready.then = readyList.then;
+
+// The ready event handler and self cleanup method
+function completed() {
+	document.removeEventListener( "DOMContentLoaded", completed );
+	window.removeEventListener( "load", completed );
+	jQuery.ready();
+}
+
+// Catch cases where $(document).ready() is called
+// after the browser event has already occurred.
+// Support: IE <=9 - 10 only
+// Older IE sometimes signals "interactive" too soon
+if ( document.readyState === "complete" ||
+	( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
+
+	// Handle it asynchronously to allow scripts the opportunity to delay ready
+	window.setTimeout( jQuery.ready );
+
+} else {
+
+	// Use the handy event callback
+	document.addEventListener( "DOMContentLoaded", completed );
+
+	// A fallback to window.onload, that will always work
+	window.addEventListener( "load", completed );
+}
+
+
+
+
+// Multifunctional method to get and set values of a collection
+// The value/s can optionally be executed if it's a function
+var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
+	var i = 0,
+		len = elems.length,
+		bulk = key == null;
+
+	// Sets many values
+	if ( toType( key ) === "object" ) {
+		chainable = true;
+		for ( i in key ) {
+			access( elems, fn, i, key[ i ], true, emptyGet, raw );
+		}
+
+	// Sets one value
+	} else if ( value !== undefined ) {
+		chainable = true;
+
+		if ( !isFunction( value ) ) {
+			raw = true;
+		}
+
+		if ( bulk ) {
+
+			// Bulk operations run against the entire set
+			if ( raw ) {
+				fn.call( elems, value );
+				fn = null;
+
+			// ...except when executing function values
+			} else {
+				bulk = fn;
+				fn = function( elem, _key, value ) {
+					return bulk.call( jQuery( elem ), value );
+				};
+			}
+		}
+
+		if ( fn ) {
+			for ( ; i < len; i++ ) {
+				fn(
+					elems[ i ], key, raw ?
+						value :
+						value.call( elems[ i ], i, fn( elems[ i ], key ) )
+				);
+			}
+		}
+	}
+
+	if ( chainable ) {
+		return elems;
+	}
+
+	// Gets
+	if ( bulk ) {
+		return fn.call( elems );
+	}
+
+	return len ? fn( elems[ 0 ], key ) : emptyGet;
+};
+
+
+// Matches dashed string for camelizing
+var rmsPrefix = /^-ms-/,
+	rdashAlpha = /-([a-z])/g;
+
+// Used by camelCase as callback to replace()
+function fcamelCase( _all, letter ) {
+	return letter.toUpperCase();
+}
+
+// Convert dashed to camelCase; used by the css and data modules
+// Support: IE <=9 - 11, Edge 12 - 15
+// Microsoft forgot to hump their vendor prefix (trac-9572)
+function camelCase( string ) {
+	return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
+}
+var acceptData = function( owner ) {
+
+	// Accepts only:
+	//  - Node
+	//    - Node.ELEMENT_NODE
+	//    - Node.DOCUMENT_NODE
+	//  - Object
+	//    - Any
+	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
+};
+
+
+
+
+function Data() {
+	this.expando = jQuery.expando + Data.uid++;
+}
+
+Data.uid = 1;
+
+Data.prototype = {
+
+	cache: function( owner ) {
+
+		// Check if the owner object already has a cache
+		var value = owner[ this.expando ];
+
+		// If not, create one
+		if ( !value ) {
+			value = {};
+
+			// We can accept data for non-element nodes in modern browsers,
+			// but we should not, see trac-8335.
+			// Always return an empty object.
+			if ( acceptData( owner ) ) {
+
+				// If it is a node unlikely to be stringify-ed or looped over
+				// use plain assignment
+				if ( owner.nodeType ) {
+					owner[ this.expando ] = value;
+
+				// Otherwise secure it in a non-enumerable property
+				// configurable must be true to allow the property to be
+				// deleted when data is removed
+				} else {
+					Object.defineProperty( owner, this.expando, {
+						value: value,
+						configurable: true
+					} );
+				}
+			}
+		}
+
+		return value;
+	},
+	set: function( owner, data, value ) {
+		var prop,
+			cache = this.cache( owner );
+
+		// Handle: [ owner, key, value ] args
+		// Always use camelCase key (gh-2257)
+		if ( typeof data === "string" ) {
+			cache[ camelCase( data ) ] = value;
+
+		// Handle: [ owner, { properties } ] args
+		} else {
+
+			// Copy the properties one-by-one to the cache object
+			for ( prop in data ) {
+				cache[ camelCase( prop ) ] = data[ prop ];
+			}
+		}
+		return cache;
+	},
+	get: function( owner, key ) {
+		return key === undefined ?
+			this.cache( owner ) :
+
+			// Always use camelCase key (gh-2257)
+			owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
+	},
+	access: function( owner, key, value ) {
+
+		// In cases where either:
+		//
+		//   1. No key was specified
+		//   2. A string key was specified, but no value provided
+		//
+		// Take the "read" path and allow the get method to determine
+		// which value to return, respectively either:
+		//
+		//   1. The entire cache object
+		//   2. The data stored at the key
+		//
+		if ( key === undefined ||
+				( ( key && typeof key === "string" ) && value === undefined ) ) {
+
+			return this.get( owner, key );
+		}
+
+		// When the key is not a string, or both a key and value
+		// are specified, set or extend (existing objects) with either:
+		//
+		//   1. An object of properties
+		//   2. A key and value
+		//
+		this.set( owner, key, value );
+
+		// Since the "set" path can have two possible entry points
+		// return the expected data based on which path was taken[*]
+		return value !== undefined ? value : key;
+	},
+	remove: function( owner, key ) {
+		var i,
+			cache = owner[ this.expando ];
+
+		if ( cache === undefined ) {
+			return;
+		}
+
+		if ( key !== undefined ) {
+
+			// Support array or space separated string of keys
+			if ( Array.isArray( key ) ) {
+
+				// If key is an array of keys...
+				// We always set camelCase keys, so remove that.
+				key = key.map( camelCase );
+			} else {
+				key = camelCase( key );
+
+				// If a key with the spaces exists, use it.
+				// Otherwise, create an array by matching non-whitespace
+				key = key in cache ?
+					[ key ] :
+					( key.match( rnothtmlwhite ) || [] );
+			}
+
+			i = key.length;
+
+			while ( i-- ) {
+				delete cache[ key[ i ] ];
+			}
+		}
+
+		// Remove the expando if there's no more data
+		if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
+
+			// Support: Chrome <=35 - 45
+			// Webkit & Blink performance suffers when deleting properties
+			// from DOM nodes, so set to undefined instead
+			// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
+			if ( owner.nodeType ) {
+				owner[ this.expando ] = undefined;
+			} else {
+				delete owner[ this.expando ];
+			}
+		}
+	},
+	hasData: function( owner ) {
+		var cache = owner[ this.expando ];
+		return cache !== undefined && !jQuery.isEmptyObject( cache );
+	}
+};
+var dataPriv = new Data();
+
+var dataUser = new Data();
+
+
+
+//	Implementation Summary
+//
+//	1. Enforce API surface and semantic compatibility with 1.9.x branch
+//	2. Improve the module's maintainability by reducing the storage
+//		paths to a single mechanism.
+//	3. Use the same single mechanism to support "private" and "user" data.
+//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
+//	5. Avoid exposing implementation details on user objects (eg. expando properties)
+//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
+
+var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
+	rmultiDash = /[A-Z]/g;
+
+function getData( data ) {
+	if ( data === "true" ) {
+		return true;
+	}
+
+	if ( data === "false" ) {
+		return false;
+	}
+
+	if ( data === "null" ) {
+		return null;
+	}
+
+	// Only convert to a number if it doesn't change the string
+	if ( data === +data + "" ) {
+		return +data;
+	}
+
+	if ( rbrace.test( data ) ) {
+		return JSON.parse( data );
+	}
+
+	return data;
+}
+
+function dataAttr( elem, key, data ) {
+	var name;
+
+	// If nothing was found internally, try to fetch any
+	// data from the HTML5 data-* attribute
+	if ( data === undefined && elem.nodeType === 1 ) {
+		name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
+		data = elem.getAttribute( name );
+
+		if ( typeof data === "string" ) {
+			try {
+				data = getData( data );
+			} catch ( e ) {}
+
+			// Make sure we set the data so it isn't changed later
+			dataUser.set( elem, key, data );
+		} else {
+			data = undefined;
+		}
+	}
+	return data;
+}
+
+jQuery.extend( {
+	hasData: function( elem ) {
+		return dataUser.hasData( elem ) || dataPriv.hasData( elem );
+	},
+
+	data: function( elem, name, data ) {
+		return dataUser.access( elem, name, data );
+	},
+
+	removeData: function( elem, name ) {
+		dataUser.remove( elem, name );
+	},
+
+	// TODO: Now that all calls to _data and _removeData have been replaced
+	// with direct calls to dataPriv methods, these can be deprecated.
+	_data: function( elem, name, data ) {
+		return dataPriv.access( elem, name, data );
+	},
+
+	_removeData: function( elem, name ) {
+		dataPriv.remove( elem, name );
+	}
+} );
+
+jQuery.fn.extend( {
+	data: function( key, value ) {
+		var i, name, data,
+			elem = this[ 0 ],
+			attrs = elem && elem.attributes;
+
+		// Gets all values
+		if ( key === undefined ) {
+			if ( this.length ) {
+				data = dataUser.get( elem );
+
+				if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
+					i = attrs.length;
+					while ( i-- ) {
+
+						// Support: IE 11 only
+						// The attrs elements can be null (trac-14894)
+						if ( attrs[ i ] ) {
+							name = attrs[ i ].name;
+							if ( name.indexOf( "data-" ) === 0 ) {
+								name = camelCase( name.slice( 5 ) );
+								dataAttr( elem, name, data[ name ] );
+							}
+						}
+					}
+					dataPriv.set( elem, "hasDataAttrs", true );
+				}
+			}
+
+			return data;
+		}
+
+		// Sets multiple values
+		if ( typeof key === "object" ) {
+			return this.each( function() {
+				dataUser.set( this, key );
+			} );
+		}
+
+		return access( this, function( value ) {
+			var data;
+
+			// The calling jQuery object (element matches) is not empty
+			// (and therefore has an element appears at this[ 0 ]) and the
+			// `value` parameter was not undefined. An empty jQuery object
+			// will result in `undefined` for elem = this[ 0 ] which will
+			// throw an exception if an attempt to read a data cache is made.
+			if ( elem && value === undefined ) {
+
+				// Attempt to get data from the cache
+				// The key will always be camelCased in Data
+				data = dataUser.get( elem, key );
+				if ( data !== undefined ) {
+					return data;
+				}
+
+				// Attempt to "discover" the data in
+				// HTML5 custom data-* attrs
+				data = dataAttr( elem, key );
+				if ( data !== undefined ) {
+					return data;
+				}
+
+				// We tried really hard, but the data doesn't exist.
+				return;
+			}
+
+			// Set the data...
+			this.each( function() {
+
+				// We always store the camelCased key
+				dataUser.set( this, key, value );
+			} );
+		}, null, value, arguments.length > 1, null, true );
+	},
+
+	removeData: function( key ) {
+		return this.each( function() {
+			dataUser.remove( this, key );
+		} );
+	}
+} );
+
+
+jQuery.extend( {
+	queue: function( elem, type, data ) {
+		var queue;
+
+		if ( elem ) {
+			type = ( type || "fx" ) + "queue";
+			queue = dataPriv.get( elem, type );
+
+			// Speed up dequeue by getting out quickly if this is just a lookup
+			if ( data ) {
+				if ( !queue || Array.isArray( data ) ) {
+					queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
+				} else {
+					queue.push( data );
+				}
+			}
+			return queue || [];
+		}
+	},
+
+	dequeue: function( elem, type ) {
+		type = type || "fx";
+
+		var queue = jQuery.queue( elem, type ),
+			startLength = queue.length,
+			fn = queue.shift(),
+			hooks = jQuery._queueHooks( elem, type ),
+			next = function() {
+				jQuery.dequeue( elem, type );
+			};
+
+		// If the fx queue is dequeued, always remove the progress sentinel
+		if ( fn === "inprogress" ) {
+			fn = queue.shift();
+			startLength--;
+		}
+
+		if ( fn ) {
+
+			// Add a progress sentinel to prevent the fx queue from being
+			// automatically dequeued
+			if ( type === "fx" ) {
+				queue.unshift( "inprogress" );
+			}
+
+			// Clear up the last queue stop function
+			delete hooks.stop;
+			fn.call( elem, next, hooks );
+		}
+
+		if ( !startLength && hooks ) {
+			hooks.empty.fire();
+		}
+	},
+
+	// Not public - generate a queueHooks object, or return the current one
+	_queueHooks: function( elem, type ) {
+		var key = type + "queueHooks";
+		return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
+			empty: jQuery.Callbacks( "once memory" ).add( function() {
+				dataPriv.remove( elem, [ type + "queue", key ] );
+			} )
+		} );
+	}
+} );
+
+jQuery.fn.extend( {
+	queue: function( type, data ) {
+		var setter = 2;
+
+		if ( typeof type !== "string" ) {
+			data = type;
+			type = "fx";
+			setter--;
+		}
+
+		if ( arguments.length < setter ) {
+			return jQuery.queue( this[ 0 ], type );
+		}
+
+		return data === undefined ?
+			this :
+			this.each( function() {
+				var queue = jQuery.queue( this, type, data );
+
+				// Ensure a hooks for this queue
+				jQuery._queueHooks( this, type );
+
+				if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
+					jQuery.dequeue( this, type );
+				}
+			} );
+	},
+	dequeue: function( type ) {
+		return this.each( function() {
+			jQuery.dequeue( this, type );
+		} );
+	},
+	clearQueue: function( type ) {
+		return this.queue( type || "fx", [] );
+	},
+
+	// Get a promise resolved when queues of a certain type
+	// are emptied (fx is the type by default)
+	promise: function( type, obj ) {
+		var tmp,
+			count = 1,
+			defer = jQuery.Deferred(),
+			elements = this,
+			i = this.length,
+			resolve = function() {
+				if ( !( --count ) ) {
+					defer.resolveWith( elements, [ elements ] );
+				}
+			};
+
+		if ( typeof type !== "string" ) {
+			obj = type;
+			type = undefined;
+		}
+		type = type || "fx";
+
+		while ( i-- ) {
+			tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
+			if ( tmp && tmp.empty ) {
+				count++;
+				tmp.empty.add( resolve );
+			}
+		}
+		resolve();
+		return defer.promise( obj );
+	}
+} );
+var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
+
+var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
+
+
+var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
+
+var documentElement = document.documentElement;
+
+
+
+	var isAttached = function( elem ) {
+			return jQuery.contains( elem.ownerDocument, elem );
+		},
+		composed = { composed: true };
+
+	// Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
+	// Check attachment across shadow DOM boundaries when possible (gh-3504)
+	// Support: iOS 10.0-10.2 only
+	// Early iOS 10 versions support `attachShadow` but not `getRootNode`,
+	// leading to errors. We need to check for `getRootNode`.
+	if ( documentElement.getRootNode ) {
+		isAttached = function( elem ) {
+			return jQuery.contains( elem.ownerDocument, elem ) ||
+				elem.getRootNode( composed ) === elem.ownerDocument;
+		};
+	}
+var isHiddenWithinTree = function( elem, el ) {
+
+		// isHiddenWithinTree might be called from jQuery#filter function;
+		// in that case, element will be second argument
+		elem = el || elem;
+
+		// Inline style trumps all
+		return elem.style.display === "none" ||
+			elem.style.display === "" &&
+
+			// Otherwise, check computed style
+			// Support: Firefox <=43 - 45
+			// Disconnected elements can have computed display: none, so first confirm that elem is
+			// in the document.
+			isAttached( elem ) &&
+
+			jQuery.css( elem, "display" ) === "none";
+	};
+
+
+
+function adjustCSS( elem, prop, valueParts, tween ) {
+	var adjusted, scale,
+		maxIterations = 20,
+		currentValue = tween ?
+			function() {
+				return tween.cur();
+			} :
+			function() {
+				return jQuery.css( elem, prop, "" );
+			},
+		initial = currentValue(),
+		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
+
+		// Starting value computation is required for potential unit mismatches
+		initialInUnit = elem.nodeType &&
+			( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
+			rcssNum.exec( jQuery.css( elem, prop ) );
+
+	if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
+
+		// Support: Firefox <=54
+		// Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
+		initial = initial / 2;
+
+		// Trust units reported by jQuery.css
+		unit = unit || initialInUnit[ 3 ];
+
+		// Iteratively approximate from a nonzero starting point
+		initialInUnit = +initial || 1;
+
+		while ( maxIterations-- ) {
+
+			// Evaluate and update our best guess (doubling guesses that zero out).
+			// Finish if the scale equals or crosses 1 (making the old*new product non-positive).
+			jQuery.style( elem, prop, initialInUnit + unit );
+			if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
+				maxIterations = 0;
+			}
+			initialInUnit = initialInUnit / scale;
+
+		}
+
+		initialInUnit = initialInUnit * 2;
+		jQuery.style( elem, prop, initialInUnit + unit );
+
+		// Make sure we update the tween properties later on
+		valueParts = valueParts || [];
+	}
+
+	if ( valueParts ) {
+		initialInUnit = +initialInUnit || +initial || 0;
+
+		// Apply relative offset (+=/-=) if specified
+		adjusted = valueParts[ 1 ] ?
+			initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
+			+valueParts[ 2 ];
+		if ( tween ) {
+			tween.unit = unit;
+			tween.start = initialInUnit;
+			tween.end = adjusted;
+		}
+	}
+	return adjusted;
+}
+
+
+var defaultDisplayMap = {};
+
+function getDefaultDisplay( elem ) {
+	var temp,
+		doc = elem.ownerDocument,
+		nodeName = elem.nodeName,
+		display = defaultDisplayMap[ nodeName ];
+
+	if ( display ) {
+		return display;
+	}
+
+	temp = doc.body.appendChild( doc.createElement( nodeName ) );
+	display = jQuery.css( temp, "display" );
+
+	temp.parentNode.removeChild( temp );
+
+	if ( display === "none" ) {
+		display = "block";
+	}
+	defaultDisplayMap[ nodeName ] = display;
+
+	return display;
+}
+
+function showHide( elements, show ) {
+	var display, elem,
+		values = [],
+		index = 0,
+		length = elements.length;
+
+	// Determine new display value for elements that need to change
+	for ( ; index < length; index++ ) {
+		elem = elements[ index ];
+		if ( !elem.style ) {
+			continue;
+		}
+
+		display = elem.style.display;
+		if ( show ) {
+
+			// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
+			// check is required in this first loop unless we have a nonempty display value (either
+			// inline or about-to-be-restored)
+			if ( display === "none" ) {
+				values[ index ] = dataPriv.get( elem, "display" ) || null;
+				if ( !values[ index ] ) {
+					elem.style.display = "";
+				}
+			}
+			if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
+				values[ index ] = getDefaultDisplay( elem );
+			}
+		} else {
+			if ( display !== "none" ) {
+				values[ index ] = "none";
+
+				// Remember what we're overwriting
+				dataPriv.set( elem, "display", display );
+			}
+		}
+	}
+
+	// Set the display of the elements in a second loop to avoid constant reflow
+	for ( index = 0; index < length; index++ ) {
+		if ( values[ index ] != null ) {
+			elements[ index ].style.display = values[ index ];
+		}
+	}
+
+	return elements;
+}
+
+jQuery.fn.extend( {
+	show: function() {
+		return showHide( this, true );
+	},
+	hide: function() {
+		return showHide( this );
+	},
+	toggle: function( state ) {
+		if ( typeof state === "boolean" ) {
+			return state ? this.show() : this.hide();
+		}
+
+		return this.each( function() {
+			if ( isHiddenWithinTree( this ) ) {
+				jQuery( this ).show();
+			} else {
+				jQuery( this ).hide();
+			}
+		} );
+	}
+} );
+var rcheckableType = ( /^(?:checkbox|radio)$/i );
+
+var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
+
+var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
+
+
+
+( function() {
+	var fragment = document.createDocumentFragment(),
+		div = fragment.appendChild( document.createElement( "div" ) ),
+		input = document.createElement( "input" );
+
+	// Support: Android 4.0 - 4.3 only
+	// Check state lost if the name is set (trac-11217)
+	// Support: Windows Web Apps (WWA)
+	// `name` and `type` must use .setAttribute for WWA (trac-14901)
+	input.setAttribute( "type", "radio" );
+	input.setAttribute( "checked", "checked" );
+	input.setAttribute( "name", "t" );
+
+	div.appendChild( input );
+
+	// Support: Android <=4.1 only
+	// Older WebKit doesn't clone checked state correctly in fragments
+	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
+
+	// Support: IE <=11 only
+	// Make sure textarea (and checkbox) defaultValue is properly cloned
+	div.innerHTML = "<textarea>x</textarea>";
+	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
+
+	// Support: IE <=9 only
+	// IE <=9 replaces <option> tags with their contents when inserted outside of
+	// the select element.
+	div.innerHTML = "<option></option>";
+	support.option = !!div.lastChild;
+} )();
+
+
+// We have to close these tags to support XHTML (trac-13200)
+var wrapMap = {
+
+	// XHTML parsers do not magically insert elements in the
+	// same way that tag soup parsers do. So we cannot shorten
+	// this by omitting <tbody> or other required elements.
+	thead: [ 1, "<table>", "</table>" ],
+	col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
+	tr: [ 2, "<table><tbody>", "</tbody></table>" ],
+	td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
+
+	_default: [ 0, "", "" ]
+};
+
+wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
+wrapMap.th = wrapMap.td;
+
+// Support: IE <=9 only
+if ( !support.option ) {
+	wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ];
+}
+
+
+function getAll( context, tag ) {
+
+	// Support: IE <=9 - 11 only
+	// Use typeof to avoid zero-argument method invocation on host objects (trac-15151)
+	var ret;
+
+	if ( typeof context.getElementsByTagName !== "undefined" ) {
+		ret = context.getElementsByTagName( tag || "*" );
+
+	} else if ( typeof context.querySelectorAll !== "undefined" ) {
+		ret = context.querySelectorAll( tag || "*" );
+
+	} else {
+		ret = [];
+	}
+
+	if ( tag === undefined || tag && nodeName( context, tag ) ) {
+		return jQuery.merge( [ context ], ret );
+	}
+
+	return ret;
+}
+
+
+// Mark scripts as having already been evaluated
+function setGlobalEval( elems, refElements ) {
+	var i = 0,
+		l = elems.length;
+
+	for ( ; i < l; i++ ) {
+		dataPriv.set(
+			elems[ i ],
+			"globalEval",
+			!refElements || dataPriv.get( refElements[ i ], "globalEval" )
+		);
+	}
+}
+
+
+var rhtml = /<|&#?\w+;/;
+
+function buildFragment( elems, context, scripts, selection, ignored ) {
+	var elem, tmp, tag, wrap, attached, j,
+		fragment = context.createDocumentFragment(),
+		nodes = [],
+		i = 0,
+		l = elems.length;
+
+	for ( ; i < l; i++ ) {
+		elem = elems[ i ];
+
+		if ( elem || elem === 0 ) {
+
+			// Add nodes directly
+			if ( toType( elem ) === "object" ) {
+
+				// Support: Android <=4.0 only, PhantomJS 1 only
+				// push.apply(_, arraylike) throws on ancient WebKit
+				jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
+
+			// Convert non-html into a text node
+			} else if ( !rhtml.test( elem ) ) {
+				nodes.push( context.createTextNode( elem ) );
+
+			// Convert html into DOM nodes
+			} else {
+				tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
+
+				// Deserialize a standard representation
+				tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
+				wrap = wrapMap[ tag ] || wrapMap._default;
+				tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
+
+				// Descend through wrappers to the right content
+				j = wrap[ 0 ];
+				while ( j-- ) {
+					tmp = tmp.lastChild;
+				}
+
+				// Support: Android <=4.0 only, PhantomJS 1 only
+				// push.apply(_, arraylike) throws on ancient WebKit
+				jQuery.merge( nodes, tmp.childNodes );
+
+				// Remember the top-level container
+				tmp = fragment.firstChild;
+
+				// Ensure the created nodes are orphaned (trac-12392)
+				tmp.textContent = "";
+			}
+		}
+	}
+
+	// Remove wrapper from fragment
+	fragment.textContent = "";
+
+	i = 0;
+	while ( ( elem = nodes[ i++ ] ) ) {
+
+		// Skip elements already in the context collection (trac-4087)
+		if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
+			if ( ignored ) {
+				ignored.push( elem );
+			}
+			continue;
+		}
+
+		attached = isAttached( elem );
+
+		// Append to fragment
+		tmp = getAll( fragment.appendChild( elem ), "script" );
+
+		// Preserve script evaluation history
+		if ( attached ) {
+			setGlobalEval( tmp );
+		}
+
+		// Capture executables
+		if ( scripts ) {
+			j = 0;
+			while ( ( elem = tmp[ j++ ] ) ) {
+				if ( rscriptType.test( elem.type || "" ) ) {
+					scripts.push( elem );
+				}
+			}
+		}
+	}
+
+	return fragment;
+}
+
+
+var rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
+
+function returnTrue() {
+	return true;
+}
+
+function returnFalse() {
+	return false;
+}
+
+function on( elem, types, selector, data, fn, one ) {
+	var origFn, type;
+
+	// Types can be a map of types/handlers
+	if ( typeof types === "object" ) {
+
+		// ( types-Object, selector, data )
+		if ( typeof selector !== "string" ) {
+
+			// ( types-Object, data )
+			data = data || selector;
+			selector = undefined;
+		}
+		for ( type in types ) {
+			on( elem, type, selector, data, types[ type ], one );
+		}
+		return elem;
+	}
+
+	if ( data == null && fn == null ) {
+
+		// ( types, fn )
+		fn = selector;
+		data = selector = undefined;
+	} else if ( fn == null ) {
+		if ( typeof selector === "string" ) {
+
+			// ( types, selector, fn )
+			fn = data;
+			data = undefined;
+		} else {
+
+			// ( types, data, fn )
+			fn = data;
+			data = selector;
+			selector = undefined;
+		}
+	}
+	if ( fn === false ) {
+		fn = returnFalse;
+	} else if ( !fn ) {
+		return elem;
+	}
+
+	if ( one === 1 ) {
+		origFn = fn;
+		fn = function( event ) {
+
+			// Can use an empty set, since event contains the info
+			jQuery().off( event );
+			return origFn.apply( this, arguments );
+		};
+
+		// Use same guid so caller can remove using origFn
+		fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
+	}
+	return elem.each( function() {
+		jQuery.event.add( this, types, fn, data, selector );
+	} );
+}
+
+/*
+ * Helper functions for managing events -- not part of the public interface.
+ * Props to Dean Edwards' addEvent library for many of the ideas.
+ */
+jQuery.event = {
+
+	global: {},
+
+	add: function( elem, types, handler, data, selector ) {
+
+		var handleObjIn, eventHandle, tmp,
+			events, t, handleObj,
+			special, handlers, type, namespaces, origType,
+			elemData = dataPriv.get( elem );
+
+		// Only attach events to objects that accept data
+		if ( !acceptData( elem ) ) {
+			return;
+		}
+
+		// Caller can pass in an object of custom data in lieu of the handler
+		if ( handler.handler ) {
+			handleObjIn = handler;
+			handler = handleObjIn.handler;
+			selector = handleObjIn.selector;
+		}
+
+		// Ensure that invalid selectors throw exceptions at attach time
+		// Evaluate against documentElement in case elem is a non-element node (e.g., document)
+		if ( selector ) {
+			jQuery.find.matchesSelector( documentElement, selector );
+		}
+
+		// Make sure that the handler has a unique ID, used to find/remove it later
+		if ( !handler.guid ) {
+			handler.guid = jQuery.guid++;
+		}
+
+		// Init the element's event structure and main handler, if this is the first
+		if ( !( events = elemData.events ) ) {
+			events = elemData.events = Object.create( null );
+		}
+		if ( !( eventHandle = elemData.handle ) ) {
+			eventHandle = elemData.handle = function( e ) {
+
+				// Discard the second event of a jQuery.event.trigger() and
+				// when an event is called after a page has unloaded
+				return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
+					jQuery.event.dispatch.apply( elem, arguments ) : undefined;
+			};
+		}
+
+		// Handle multiple events separated by a space
+		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
+		t = types.length;
+		while ( t-- ) {
+			tmp = rtypenamespace.exec( types[ t ] ) || [];
+			type = origType = tmp[ 1 ];
+			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
+
+			// There *must* be a type, no attaching namespace-only handlers
+			if ( !type ) {
+				continue;
+			}
+
+			// If event changes its type, use the special event handlers for the changed type
+			special = jQuery.event.special[ type ] || {};
+
+			// If selector defined, determine special event api type, otherwise given type
+			type = ( selector ? special.delegateType : special.bindType ) || type;
+
+			// Update special based on newly reset type
+			special = jQuery.event.special[ type ] || {};
+
+			// handleObj is passed to all event handlers
+			handleObj = jQuery.extend( {
+				type: type,
+				origType: origType,
+				data: data,
+				handler: handler,
+				guid: handler.guid,
+				selector: selector,
+				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
+				namespace: namespaces.join( "." )
+			}, handleObjIn );
+
+			// Init the event handler queue if we're the first
+			if ( !( handlers = events[ type ] ) ) {
+				handlers = events[ type ] = [];
+				handlers.delegateCount = 0;
+
+				// Only use addEventListener if the special events handler returns false
+				if ( !special.setup ||
+					special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
+
+					if ( elem.addEventListener ) {
+						elem.addEventListener( type, eventHandle );
+					}
+				}
+			}
+
+			if ( special.add ) {
+				special.add.call( elem, handleObj );
+
+				if ( !handleObj.handler.guid ) {
+					handleObj.handler.guid = handler.guid;
+				}
+			}
+
+			// Add to the element's handler list, delegates in front
+			if ( selector ) {
+				handlers.splice( handlers.delegateCount++, 0, handleObj );
+			} else {
+				handlers.push( handleObj );
+			}
+
+			// Keep track of which events have ever been used, for event optimization
+			jQuery.event.global[ type ] = true;
+		}
+
+	},
+
+	// Detach an event or set of events from an element
+	remove: function( elem, types, handler, selector, mappedTypes ) {
+
+		var j, origCount, tmp,
+			events, t, handleObj,
+			special, handlers, type, namespaces, origType,
+			elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
+
+		if ( !elemData || !( events = elemData.events ) ) {
+			return;
+		}
+
+		// Once for each type.namespace in types; type may be omitted
+		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
+		t = types.length;
+		while ( t-- ) {
+			tmp = rtypenamespace.exec( types[ t ] ) || [];
+			type = origType = tmp[ 1 ];
+			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
+
+			// Unbind all events (on this namespace, if provided) for the element
+			if ( !type ) {
+				for ( type in events ) {
+					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
+				}
+				continue;
+			}
+
+			special = jQuery.event.special[ type ] || {};
+			type = ( selector ? special.delegateType : special.bindType ) || type;
+			handlers = events[ type ] || [];
+			tmp = tmp[ 2 ] &&
+				new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
+
+			// Remove matching events
+			origCount = j = handlers.length;
+			while ( j-- ) {
+				handleObj = handlers[ j ];
+
+				if ( ( mappedTypes || origType === handleObj.origType ) &&
+					( !handler || handler.guid === handleObj.guid ) &&
+					( !tmp || tmp.test( handleObj.namespace ) ) &&
+					( !selector || selector === handleObj.selector ||
+						selector === "**" && handleObj.selector ) ) {
+					handlers.splice( j, 1 );
+
+					if ( handleObj.selector ) {
+						handlers.delegateCount--;
+					}
+					if ( special.remove ) {
+						special.remove.call( elem, handleObj );
+					}
+				}
+			}
+
+			// Remove generic event handler if we removed something and no more handlers exist
+			// (avoids potential for endless recursion during removal of special event handlers)
+			if ( origCount && !handlers.length ) {
+				if ( !special.teardown ||
+					special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
+
+					jQuery.removeEvent( elem, type, elemData.handle );
+				}
+
+				delete events[ type ];
+			}
+		}
+
+		// Remove data and the expando if it's no longer used
+		if ( jQuery.isEmptyObject( events ) ) {
+			dataPriv.remove( elem, "handle events" );
+		}
+	},
+
+	dispatch: function( nativeEvent ) {
+
+		var i, j, ret, matched, handleObj, handlerQueue,
+			args = new Array( arguments.length ),
+
+			// Make a writable jQuery.Event from the native event object
+			event = jQuery.event.fix( nativeEvent ),
+
+			handlers = (
+				dataPriv.get( this, "events" ) || Object.create( null )
+			)[ event.type ] || [],
+			special = jQuery.event.special[ event.type ] || {};
+
+		// Use the fix-ed jQuery.Event rather than the (read-only) native event
+		args[ 0 ] = event;
+
+		for ( i = 1; i < arguments.length; i++ ) {
+			args[ i ] = arguments[ i ];
+		}
+
+		event.delegateTarget = this;
+
+		// Call the preDispatch hook for the mapped type, and let it bail if desired
+		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
+			return;
+		}
+
+		// Determine handlers
+		handlerQueue = jQuery.event.handlers.call( this, event, handlers );
+
+		// Run delegates first; they may want to stop propagation beneath us
+		i = 0;
+		while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
+			event.currentTarget = matched.elem;
+
+			j = 0;
+			while ( ( handleObj = matched.handlers[ j++ ] ) &&
+				!event.isImmediatePropagationStopped() ) {
+
+				// If the event is namespaced, then each handler is only invoked if it is
+				// specially universal or its namespaces are a superset of the event's.
+				if ( !event.rnamespace || handleObj.namespace === false ||
+					event.rnamespace.test( handleObj.namespace ) ) {
+
+					event.handleObj = handleObj;
+					event.data = handleObj.data;
+
+					ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
+						handleObj.handler ).apply( matched.elem, args );
+
+					if ( ret !== undefined ) {
+						if ( ( event.result = ret ) === false ) {
+							event.preventDefault();
+							event.stopPropagation();
+						}
+					}
+				}
+			}
+		}
+
+		// Call the postDispatch hook for the mapped type
+		if ( special.postDispatch ) {
+			special.postDispatch.call( this, event );
+		}
+
+		return event.result;
+	},
+
+	handlers: function( event, handlers ) {
+		var i, handleObj, sel, matchedHandlers, matchedSelectors,
+			handlerQueue = [],
+			delegateCount = handlers.delegateCount,
+			cur = event.target;
+
+		// Find delegate handlers
+		if ( delegateCount &&
+
+			// Support: IE <=9
+			// Black-hole SVG <use> instance trees (trac-13180)
+			cur.nodeType &&
+
+			// Support: Firefox <=42
+			// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
+			// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
+			// Support: IE 11 only
+			// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
+			!( event.type === "click" && event.button >= 1 ) ) {
+
+			for ( ; cur !== this; cur = cur.parentNode || this ) {
+
+				// Don't check non-elements (trac-13208)
+				// Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764)
+				if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
+					matchedHandlers = [];
+					matchedSelectors = {};
+					for ( i = 0; i < delegateCount; i++ ) {
+						handleObj = handlers[ i ];
+
+						// Don't conflict with Object.prototype properties (trac-13203)
+						sel = handleObj.selector + " ";
+
+						if ( matchedSelectors[ sel ] === undefined ) {
+							matchedSelectors[ sel ] = handleObj.needsContext ?
+								jQuery( sel, this ).index( cur ) > -1 :
+								jQuery.find( sel, this, null, [ cur ] ).length;
+						}
+						if ( matchedSelectors[ sel ] ) {
+							matchedHandlers.push( handleObj );
+						}
+					}
+					if ( matchedHandlers.length ) {
+						handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
+					}
+				}
+			}
+		}
+
+		// Add the remaining (directly-bound) handlers
+		cur = this;
+		if ( delegateCount < handlers.length ) {
+			handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
+		}
+
+		return handlerQueue;
+	},
+
+	addProp: function( name, hook ) {
+		Object.defineProperty( jQuery.Event.prototype, name, {
+			enumerable: true,
+			configurable: true,
+
+			get: isFunction( hook ) ?
+				function() {
+					if ( this.originalEvent ) {
+						return hook( this.originalEvent );
+					}
+				} :
+				function() {
+					if ( this.originalEvent ) {
+						return this.originalEvent[ name ];
+					}
+				},
+
+			set: function( value ) {
+				Object.defineProperty( this, name, {
+					enumerable: true,
+					configurable: true,
+					writable: true,
+					value: value
+				} );
+			}
+		} );
+	},
+
+	fix: function( originalEvent ) {
+		return originalEvent[ jQuery.expando ] ?
+			originalEvent :
+			new jQuery.Event( originalEvent );
+	},
+
+	special: {
+		load: {
+
+			// Prevent triggered image.load events from bubbling to window.load
+			noBubble: true
+		},
+		click: {
+
+			// Utilize native event to ensure correct state for checkable inputs
+			setup: function( data ) {
+
+				// For mutual compressibility with _default, replace `this` access with a local var.
+				// `|| data` is dead code meant only to preserve the variable through minification.
+				var el = this || data;
+
+				// Claim the first handler
+				if ( rcheckableType.test( el.type ) &&
+					el.click && nodeName( el, "input" ) ) {
+
+					// dataPriv.set( el, "click", ... )
+					leverageNative( el, "click", true );
+				}
+
+				// Return false to allow normal processing in the caller
+				return false;
+			},
+			trigger: function( data ) {
+
+				// For mutual compressibility with _default, replace `this` access with a local var.
+				// `|| data` is dead code meant only to preserve the variable through minification.
+				var el = this || data;
+
+				// Force setup before triggering a click
+				if ( rcheckableType.test( el.type ) &&
+					el.click && nodeName( el, "input" ) ) {
+
+					leverageNative( el, "click" );
+				}
+
+				// Return non-false to allow normal event-path propagation
+				return true;
+			},
+
+			// For cross-browser consistency, suppress native .click() on links
+			// Also prevent it if we're currently inside a leveraged native-event stack
+			_default: function( event ) {
+				var target = event.target;
+				return rcheckableType.test( target.type ) &&
+					target.click && nodeName( target, "input" ) &&
+					dataPriv.get( target, "click" ) ||
+					nodeName( target, "a" );
+			}
+		},
+
+		beforeunload: {
+			postDispatch: function( event ) {
+
+				// Support: Firefox 20+
+				// Firefox doesn't alert if the returnValue field is not set.
+				if ( event.result !== undefined && event.originalEvent ) {
+					event.originalEvent.returnValue = event.result;
+				}
+			}
+		}
+	}
+};
+
+// Ensure the presence of an event listener that handles manually-triggered
+// synthetic events by interrupting progress until reinvoked in response to
+// *native* events that it fires directly, ensuring that state changes have
+// already occurred before other listeners are invoked.
+function leverageNative( el, type, isSetup ) {
+
+	// Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add
+	if ( !isSetup ) {
+		if ( dataPriv.get( el, type ) === undefined ) {
+			jQuery.event.add( el, type, returnTrue );
+		}
+		return;
+	}
+
+	// Register the controller as a special universal handler for all event namespaces
+	dataPriv.set( el, type, false );
+	jQuery.event.add( el, type, {
+		namespace: false,
+		handler: function( event ) {
+			var result,
+				saved = dataPriv.get( this, type );
+
+			if ( ( event.isTrigger & 1 ) && this[ type ] ) {
+
+				// Interrupt processing of the outer synthetic .trigger()ed event
+				if ( !saved ) {
+
+					// Store arguments for use when handling the inner native event
+					// There will always be at least one argument (an event object), so this array
+					// will not be confused with a leftover capture object.
+					saved = slice.call( arguments );
+					dataPriv.set( this, type, saved );
+
+					// Trigger the native event and capture its result
+					this[ type ]();
+					result = dataPriv.get( this, type );
+					dataPriv.set( this, type, false );
+
+					if ( saved !== result ) {
+
+						// Cancel the outer synthetic event
+						event.stopImmediatePropagation();
+						event.preventDefault();
+
+						return result;
+					}
+
+				// If this is an inner synthetic event for an event with a bubbling surrogate
+				// (focus or blur), assume that the surrogate already propagated from triggering
+				// the native event and prevent that from happening again here.
+				// This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
+				// bubbling surrogate propagates *after* the non-bubbling base), but that seems
+				// less bad than duplication.
+				} else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {
+					event.stopPropagation();
+				}
+
+			// If this is a native event triggered above, everything is now in order
+			// Fire an inner synthetic event with the original arguments
+			} else if ( saved ) {
+
+				// ...and capture the result
+				dataPriv.set( this, type, jQuery.event.trigger(
+					saved[ 0 ],
+					saved.slice( 1 ),
+					this
+				) );
+
+				// Abort handling of the native event by all jQuery handlers while allowing
+				// native handlers on the same element to run. On target, this is achieved
+				// by stopping immediate propagation just on the jQuery event. However,
+				// the native event is re-wrapped by a jQuery one on each level of the
+				// propagation so the only way to stop it for jQuery is to stop it for
+				// everyone via native `stopPropagation()`. This is not a problem for
+				// focus/blur which don't bubble, but it does also stop click on checkboxes
+				// and radios. We accept this limitation.
+				event.stopPropagation();
+				event.isImmediatePropagationStopped = returnTrue;
+			}
+		}
+	} );
+}
+
+jQuery.removeEvent = function( elem, type, handle ) {
+
+	// This "if" is needed for plain objects
+	if ( elem.removeEventListener ) {
+		elem.removeEventListener( type, handle );
+	}
+};
+
+jQuery.Event = function( src, props ) {
+
+	// Allow instantiation without the 'new' keyword
+	if ( !( this instanceof jQuery.Event ) ) {
+		return new jQuery.Event( src, props );
+	}
+
+	// Event object
+	if ( src && src.type ) {
+		this.originalEvent = src;
+		this.type = src.type;
+
+		// Events bubbling up the document may have been marked as prevented
+		// by a handler lower down the tree; reflect the correct value.
+		this.isDefaultPrevented = src.defaultPrevented ||
+				src.defaultPrevented === undefined &&
+
+				// Support: Android <=2.3 only
+				src.returnValue === false ?
+			returnTrue :
+			returnFalse;
+
+		// Create target properties
+		// Support: Safari <=6 - 7 only
+		// Target should not be a text node (trac-504, trac-13143)
+		this.target = ( src.target && src.target.nodeType === 3 ) ?
+			src.target.parentNode :
+			src.target;
+
+		this.currentTarget = src.currentTarget;
+		this.relatedTarget = src.relatedTarget;
+
+	// Event type
+	} else {
+		this.type = src;
+	}
+
+	// Put explicitly provided properties onto the event object
+	if ( props ) {
+		jQuery.extend( this, props );
+	}
+
+	// Create a timestamp if incoming event doesn't have one
+	this.timeStamp = src && src.timeStamp || Date.now();
+
+	// Mark it as fixed
+	this[ jQuery.expando ] = true;
+};
+
+// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
+// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
+jQuery.Event.prototype = {
+	constructor: jQuery.Event,
+	isDefaultPrevented: returnFalse,
+	isPropagationStopped: returnFalse,
+	isImmediatePropagationStopped: returnFalse,
+	isSimulated: false,
+
+	preventDefault: function() {
+		var e = this.originalEvent;
+
+		this.isDefaultPrevented = returnTrue;
+
+		if ( e && !this.isSimulated ) {
+			e.preventDefault();
+		}
+	},
+	stopPropagation: function() {
+		var e = this.originalEvent;
+
+		this.isPropagationStopped = returnTrue;
+
+		if ( e && !this.isSimulated ) {
+			e.stopPropagation();
+		}
+	},
+	stopImmediatePropagation: function() {
+		var e = this.originalEvent;
+
+		this.isImmediatePropagationStopped = returnTrue;
+
+		if ( e && !this.isSimulated ) {
+			e.stopImmediatePropagation();
+		}
+
+		this.stopPropagation();
+	}
+};
+
+// Includes all common event props including KeyEvent and MouseEvent specific props
+jQuery.each( {
+	altKey: true,
+	bubbles: true,
+	cancelable: true,
+	changedTouches: true,
+	ctrlKey: true,
+	detail: true,
+	eventPhase: true,
+	metaKey: true,
+	pageX: true,
+	pageY: true,
+	shiftKey: true,
+	view: true,
+	"char": true,
+	code: true,
+	charCode: true,
+	key: true,
+	keyCode: true,
+	button: true,
+	buttons: true,
+	clientX: true,
+	clientY: true,
+	offsetX: true,
+	offsetY: true,
+	pointerId: true,
+	pointerType: true,
+	screenX: true,
+	screenY: true,
+	targetTouches: true,
+	toElement: true,
+	touches: true,
+	which: true
+}, jQuery.event.addProp );
+
+jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
+
+	function focusMappedHandler( nativeEvent ) {
+		if ( document.documentMode ) {
+
+			// Support: IE 11+
+			// Attach a single focusin/focusout handler on the document while someone wants
+			// focus/blur. This is because the former are synchronous in IE while the latter
+			// are async. In other browsers, all those handlers are invoked synchronously.
+
+			// `handle` from private data would already wrap the event, but we need
+			// to change the `type` here.
+			var handle = dataPriv.get( this, "handle" ),
+				event = jQuery.event.fix( nativeEvent );
+			event.type = nativeEvent.type === "focusin" ? "focus" : "blur";
+			event.isSimulated = true;
+
+			// First, handle focusin/focusout
+			handle( nativeEvent );
+
+			// ...then, handle focus/blur
+			//
+			// focus/blur don't bubble while focusin/focusout do; simulate the former by only
+			// invoking the handler at the lower level.
+			if ( event.target === event.currentTarget ) {
+
+				// The setup part calls `leverageNative`, which, in turn, calls
+				// `jQuery.event.add`, so event handle will already have been set
+				// by this point.
+				handle( event );
+			}
+		} else {
+
+			// For non-IE browsers, attach a single capturing handler on the document
+			// while someone wants focusin/focusout.
+			jQuery.event.simulate( delegateType, nativeEvent.target,
+				jQuery.event.fix( nativeEvent ) );
+		}
+	}
+
+	jQuery.event.special[ type ] = {
+
+		// Utilize native event if possible so blur/focus sequence is correct
+		setup: function() {
+
+			var attaches;
+
+			// Claim the first handler
+			// dataPriv.set( this, "focus", ... )
+			// dataPriv.set( this, "blur", ... )
+			leverageNative( this, type, true );
+
+			if ( document.documentMode ) {
+
+				// Support: IE 9 - 11+
+				// We use the same native handler for focusin & focus (and focusout & blur)
+				// so we need to coordinate setup & teardown parts between those events.
+				// Use `delegateType` as the key as `type` is already used by `leverageNative`.
+				attaches = dataPriv.get( this, delegateType );
+				if ( !attaches ) {
+					this.addEventListener( delegateType, focusMappedHandler );
+				}
+				dataPriv.set( this, delegateType, ( attaches || 0 ) + 1 );
+			} else {
+
+				// Return false to allow normal processing in the caller
+				return false;
+			}
+		},
+		trigger: function() {
+
+			// Force setup before trigger
+			leverageNative( this, type );
+
+			// Return non-false to allow normal event-path propagation
+			return true;
+		},
+
+		teardown: function() {
+			var attaches;
+
+			if ( document.documentMode ) {
+				attaches = dataPriv.get( this, delegateType ) - 1;
+				if ( !attaches ) {
+					this.removeEventListener( delegateType, focusMappedHandler );
+					dataPriv.remove( this, delegateType );
+				} else {
+					dataPriv.set( this, delegateType, attaches );
+				}
+			} else {
+
+				// Return false to indicate standard teardown should be applied
+				return false;
+			}
+		},
+
+		// Suppress native focus or blur if we're currently inside
+		// a leveraged native-event stack
+		_default: function( event ) {
+			return dataPriv.get( event.target, type );
+		},
+
+		delegateType: delegateType
+	};
+
+	// Support: Firefox <=44
+	// Firefox doesn't have focus(in | out) events
+	// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
+	//
+	// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
+	// focus(in | out) events fire after focus & blur events,
+	// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
+	// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
+	//
+	// Support: IE 9 - 11+
+	// To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch,
+	// attach a single handler for both events in IE.
+	jQuery.event.special[ delegateType ] = {
+		setup: function() {
+
+			// Handle: regular nodes (via `this.ownerDocument`), window
+			// (via `this.document`) & document (via `this`).
+			var doc = this.ownerDocument || this.document || this,
+				dataHolder = document.documentMode ? this : doc,
+				attaches = dataPriv.get( dataHolder, delegateType );
+
+			// Support: IE 9 - 11+
+			// We use the same native handler for focusin & focus (and focusout & blur)
+			// so we need to coordinate setup & teardown parts between those events.
+			// Use `delegateType` as the key as `type` is already used by `leverageNative`.
+			if ( !attaches ) {
+				if ( document.documentMode ) {
+					this.addEventListener( delegateType, focusMappedHandler );
+				} else {
+					doc.addEventListener( type, focusMappedHandler, true );
+				}
+			}
+			dataPriv.set( dataHolder, delegateType, ( attaches || 0 ) + 1 );
+		},
+		teardown: function() {
+			var doc = this.ownerDocument || this.document || this,
+				dataHolder = document.documentMode ? this : doc,
+				attaches = dataPriv.get( dataHolder, delegateType ) - 1;
+
+			if ( !attaches ) {
+				if ( document.documentMode ) {
+					this.removeEventListener( delegateType, focusMappedHandler );
+				} else {
+					doc.removeEventListener( type, focusMappedHandler, true );
+				}
+				dataPriv.remove( dataHolder, delegateType );
+			} else {
+				dataPriv.set( dataHolder, delegateType, attaches );
+			}
+		}
+	};
+} );
+
+// Create mouseenter/leave events using mouseover/out and event-time checks
+// so that event delegation works in jQuery.
+// Do the same for pointerenter/pointerleave and pointerover/pointerout
+//
+// Support: Safari 7 only
+// Safari sends mouseenter too often; see:
+// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
+// for the description of the bug (it existed in older Chrome versions as well).
+jQuery.each( {
+	mouseenter: "mouseover",
+	mouseleave: "mouseout",
+	pointerenter: "pointerover",
+	pointerleave: "pointerout"
+}, function( orig, fix ) {
+	jQuery.event.special[ orig ] = {
+		delegateType: fix,
+		bindType: fix,
+
+		handle: function( event ) {
+			var ret,
+				target = this,
+				related = event.relatedTarget,
+				handleObj = event.handleObj;
+
+			// For mouseenter/leave call the handler if related is outside the target.
+			// NB: No relatedTarget if the mouse left/entered the browser window
+			if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
+				event.type = handleObj.origType;
+				ret = handleObj.handler.apply( this, arguments );
+				event.type = fix;
+			}
+			return ret;
+		}
+	};
+} );
+
+jQuery.fn.extend( {
+
+	on: function( types, selector, data, fn ) {
+		return on( this, types, selector, data, fn );
+	},
+	one: function( types, selector, data, fn ) {
+		return on( this, types, selector, data, fn, 1 );
+	},
+	off: function( types, selector, fn ) {
+		var handleObj, type;
+		if ( types && types.preventDefault && types.handleObj ) {
+
+			// ( event )  dispatched jQuery.Event
+			handleObj = types.handleObj;
+			jQuery( types.delegateTarget ).off(
+				handleObj.namespace ?
+					handleObj.origType + "." + handleObj.namespace :
+					handleObj.origType,
+				handleObj.selector,
+				handleObj.handler
+			);
+			return this;
+		}
+		if ( typeof types === "object" ) {
+
+			// ( types-object [, selector] )
+			for ( type in types ) {
+				this.off( type, selector, types[ type ] );
+			}
+			return this;
+		}
+		if ( selector === false || typeof selector === "function" ) {
+
+			// ( types [, fn] )
+			fn = selector;
+			selector = undefined;
+		}
+		if ( fn === false ) {
+			fn = returnFalse;
+		}
+		return this.each( function() {
+			jQuery.event.remove( this, types, fn, selector );
+		} );
+	}
+} );
+
+
+var
+
+	// Support: IE <=10 - 11, Edge 12 - 13 only
+	// In IE/Edge using regex groups here causes severe slowdowns.
+	// See https://connect.microsoft.com/IE/feedback/details/1736512/
+	rnoInnerhtml = /<script|<style|<link/i,
+
+	// checked="checked" or checked
+	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
+
+	rcleanScript = /^\s*<!\[CDATA\[|\]\]>\s*$/g;
+
+// Prefer a tbody over its parent table for containing new rows
+function manipulationTarget( elem, content ) {
+	if ( nodeName( elem, "table" ) &&
+		nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
+
+		return jQuery( elem ).children( "tbody" )[ 0 ] || elem;
+	}
+
+	return elem;
+}
+
+// Replace/restore the type attribute of script elements for safe DOM manipulation
+function disableScript( elem ) {
+	elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
+	return elem;
+}
+function restoreScript( elem ) {
+	if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {
+		elem.type = elem.type.slice( 5 );
+	} else {
+		elem.removeAttribute( "type" );
+	}
+
+	return elem;
+}
+
+function cloneCopyEvent( src, dest ) {
+	var i, l, type, pdataOld, udataOld, udataCur, events;
+
+	if ( dest.nodeType !== 1 ) {
+		return;
+	}
+
+	// 1. Copy private data: events, handlers, etc.
+	if ( dataPriv.hasData( src ) ) {
+		pdataOld = dataPriv.get( src );
+		events = pdataOld.events;
+
+		if ( events ) {
+			dataPriv.remove( dest, "handle events" );
+
+			for ( type in events ) {
+				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
+					jQuery.event.add( dest, type, events[ type ][ i ] );
+				}
+			}
+		}
+	}
+
+	// 2. Copy user data
+	if ( dataUser.hasData( src ) ) {
+		udataOld = dataUser.access( src );
+		udataCur = jQuery.extend( {}, udataOld );
+
+		dataUser.set( dest, udataCur );
+	}
+}
+
+// Fix IE bugs, see support tests
+function fixInput( src, dest ) {
+	var nodeName = dest.nodeName.toLowerCase();
+
+	// Fails to persist the checked state of a cloned checkbox or radio button.
+	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
+		dest.checked = src.checked;
+
+	// Fails to return the selected option to the default selected state when cloning options
+	} else if ( nodeName === "input" || nodeName === "textarea" ) {
+		dest.defaultValue = src.defaultValue;
+	}
+}
+
+function domManip( collection, args, callback, ignored ) {
+
+	// Flatten any nested arrays
+	args = flat( args );
+
+	var fragment, first, scripts, hasScripts, node, doc,
+		i = 0,
+		l = collection.length,
+		iNoClone = l - 1,
+		value = args[ 0 ],
+		valueIsFunction = isFunction( value );
+
+	// We can't cloneNode fragments that contain checked, in WebKit
+	if ( valueIsFunction ||
+			( l > 1 && typeof value === "string" &&
+				!support.checkClone && rchecked.test( value ) ) ) {
+		return collection.each( function( index ) {
+			var self = collection.eq( index );
+			if ( valueIsFunction ) {
+				args[ 0 ] = value.call( this, index, self.html() );
+			}
+			domManip( self, args, callback, ignored );
+		} );
+	}
+
+	if ( l ) {
+		fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
+		first = fragment.firstChild;
+
+		if ( fragment.childNodes.length === 1 ) {
+			fragment = first;
+		}
+
+		// Require either new content or an interest in ignored elements to invoke the callback
+		if ( first || ignored ) {
+			scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
+			hasScripts = scripts.length;
+
+			// Use the original fragment for the last item
+			// instead of the first because it can end up
+			// being emptied incorrectly in certain situations (trac-8070).
+			for ( ; i < l; i++ ) {
+				node = fragment;
+
+				if ( i !== iNoClone ) {
+					node = jQuery.clone( node, true, true );
+
+					// Keep references to cloned scripts for later restoration
+					if ( hasScripts ) {
+
+						// Support: Android <=4.0 only, PhantomJS 1 only
+						// push.apply(_, arraylike) throws on ancient WebKit
+						jQuery.merge( scripts, getAll( node, "script" ) );
+					}
+				}
+
+				callback.call( collection[ i ], node, i );
+			}
+
+			if ( hasScripts ) {
+				doc = scripts[ scripts.length - 1 ].ownerDocument;
+
+				// Re-enable scripts
+				jQuery.map( scripts, restoreScript );
+
+				// Evaluate executable scripts on first document insertion
+				for ( i = 0; i < hasScripts; i++ ) {
+					node = scripts[ i ];
+					if ( rscriptType.test( node.type || "" ) &&
+						!dataPriv.access( node, "globalEval" ) &&
+						jQuery.contains( doc, node ) ) {
+
+						if ( node.src && ( node.type || "" ).toLowerCase()  !== "module" ) {
+
+							// Optional AJAX dependency, but won't run scripts if not present
+							if ( jQuery._evalUrl && !node.noModule ) {
+								jQuery._evalUrl( node.src, {
+									nonce: node.nonce || node.getAttribute( "nonce" )
+								}, doc );
+							}
+						} else {
+
+							// Unwrap a CDATA section containing script contents. This shouldn't be
+							// needed as in XML documents they're already not visible when
+							// inspecting element contents and in HTML documents they have no
+							// meaning but we're preserving that logic for backwards compatibility.
+							// This will be removed completely in 4.0. See gh-4904.
+							DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc );
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return collection;
+}
+
+function remove( elem, selector, keepData ) {
+	var node,
+		nodes = selector ? jQuery.filter( selector, elem ) : elem,
+		i = 0;
+
+	for ( ; ( node = nodes[ i ] ) != null; i++ ) {
+		if ( !keepData && node.nodeType === 1 ) {
+			jQuery.cleanData( getAll( node ) );
+		}
+
+		if ( node.parentNode ) {
+			if ( keepData && isAttached( node ) ) {
+				setGlobalEval( getAll( node, "script" ) );
+			}
+			node.parentNode.removeChild( node );
+		}
+	}
+
+	return elem;
+}
+
+jQuery.extend( {
+	htmlPrefilter: function( html ) {
+		return html;
+	},
+
+	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
+		var i, l, srcElements, destElements,
+			clone = elem.cloneNode( true ),
+			inPage = isAttached( elem );
+
+		// Fix IE cloning issues
+		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
+				!jQuery.isXMLDoc( elem ) ) {
+
+			// We eschew jQuery#find here for performance reasons:
+			// https://jsperf.com/getall-vs-sizzle/2
+			destElements = getAll( clone );
+			srcElements = getAll( elem );
+
+			for ( i = 0, l = srcElements.length; i < l; i++ ) {
+				fixInput( srcElements[ i ], destElements[ i ] );
+			}
+		}
+
+		// Copy the events from the original to the clone
+		if ( dataAndEvents ) {
+			if ( deepDataAndEvents ) {
+				srcElements = srcElements || getAll( elem );
+				destElements = destElements || getAll( clone );
+
+				for ( i = 0, l = srcElements.length; i < l; i++ ) {
+					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
+				}
+			} else {
+				cloneCopyEvent( elem, clone );
+			}
+		}
+
+		// Preserve script evaluation history
+		destElements = getAll( clone, "script" );
+		if ( destElements.length > 0 ) {
+			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
+		}
+
+		// Return the cloned set
+		return clone;
+	},
+
+	cleanData: function( elems ) {
+		var data, elem, type,
+			special = jQuery.event.special,
+			i = 0;
+
+		for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
+			if ( acceptData( elem ) ) {
+				if ( ( data = elem[ dataPriv.expando ] ) ) {
+					if ( data.events ) {
+						for ( type in data.events ) {
+							if ( special[ type ] ) {
+								jQuery.event.remove( elem, type );
+
+							// This is a shortcut to avoid jQuery.event.remove's overhead
+							} else {
+								jQuery.removeEvent( elem, type, data.handle );
+							}
+						}
+					}
+
+					// Support: Chrome <=35 - 45+
+					// Assign undefined instead of using delete, see Data#remove
+					elem[ dataPriv.expando ] = undefined;
+				}
+				if ( elem[ dataUser.expando ] ) {
+
+					// Support: Chrome <=35 - 45+
+					// Assign undefined instead of using delete, see Data#remove
+					elem[ dataUser.expando ] = undefined;
+				}
+			}
+		}
+	}
+} );
+
+jQuery.fn.extend( {
+	detach: function( selector ) {
+		return remove( this, selector, true );
+	},
+
+	remove: function( selector ) {
+		return remove( this, selector );
+	},
+
+	text: function( value ) {
+		return access( this, function( value ) {
+			return value === undefined ?
+				jQuery.text( this ) :
+				this.empty().each( function() {
+					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+						this.textContent = value;
+					}
+				} );
+		}, null, value, arguments.length );
+	},
+
+	append: function() {
+		return domManip( this, arguments, function( elem ) {
+			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+				var target = manipulationTarget( this, elem );
+				target.appendChild( elem );
+			}
+		} );
+	},
+
+	prepend: function() {
+		return domManip( this, arguments, function( elem ) {
+			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
+				var target = manipulationTarget( this, elem );
+				target.insertBefore( elem, target.firstChild );
+			}
+		} );
+	},
+
+	before: function() {
+		return domManip( this, arguments, function( elem ) {
+			if ( this.parentNode ) {
+				this.parentNode.insertBefore( elem, this );
+			}
+		} );
+	},
+
+	after: function() {
+		return domManip( this, arguments, function( elem ) {
+			if ( this.parentNode ) {
+				this.parentNode.insertBefore( elem, this.nextSibling );
+			}
+		} );
+	},
+
+	empty: function() {
+		var elem,
+			i = 0;
+
+		for ( ; ( elem = this[ i ] ) != null; i++ ) {
+			if ( elem.nodeType === 1 ) {
+
+				// Prevent memory leaks
+				jQuery.cleanData( getAll( elem, false ) );
+
+				// Remove any remaining nodes
+				elem.textContent = "";
+			}
+		}
+
+		return this;
+	},
+
+	clone: function( dataAndEvents, deepDataAndEvents ) {
+		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
+		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
+
+		return this.map( function() {
+			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
+		} );
+	},
+
+	html: function( value ) {
+		return access( this, function( value ) {
+			var elem = this[ 0 ] || {},
+				i = 0,
+				l = this.length;
+
+			if ( value === undefined && elem.nodeType === 1 ) {
+				return elem.innerHTML;
+			}
+
+			// See if we can take a shortcut and just use innerHTML
+			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
+				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
+
+				value = jQuery.htmlPrefilter( value );
+
+				try {
+					for ( ; i < l; i++ ) {
+						elem = this[ i ] || {};
+
+						// Remove element nodes and prevent memory leaks
+						if ( elem.nodeType === 1 ) {
+							jQuery.cleanData( getAll( elem, false ) );
+							elem.innerHTML = value;
+						}
+					}
+
+					elem = 0;
+
+				// If using innerHTML throws an exception, use the fallback method
+				} catch ( e ) {}
+			}
+
+			if ( elem ) {
+				this.empty().append( value );
+			}
+		}, null, value, arguments.length );
+	},
+
+	replaceWith: function() {
+		var ignored = [];
+
+		// Make the changes, replacing each non-ignored context element with the new content
+		return domManip( this, arguments, function( elem ) {
+			var parent = this.parentNode;
+
+			if ( jQuery.inArray( this, ignored ) < 0 ) {
+				jQuery.cleanData( getAll( this ) );
+				if ( parent ) {
+					parent.replaceChild( elem, this );
+				}
+			}
+
+		// Force callback invocation
+		}, ignored );
+	}
+} );
+
+jQuery.each( {
+	appendTo: "append",
+	prependTo: "prepend",
+	insertBefore: "before",
+	insertAfter: "after",
+	replaceAll: "replaceWith"
+}, function( name, original ) {
+	jQuery.fn[ name ] = function( selector ) {
+		var elems,
+			ret = [],
+			insert = jQuery( selector ),
+			last = insert.length - 1,
+			i = 0;
+
+		for ( ; i <= last; i++ ) {
+			elems = i === last ? this : this.clone( true );
+			jQuery( insert[ i ] )[ original ]( elems );
+
+			// Support: Android <=4.0 only, PhantomJS 1 only
+			// .get() because push.apply(_, arraylike) throws on ancient WebKit
+			push.apply( ret, elems.get() );
+		}
+
+		return this.pushStack( ret );
+	};
+} );
+var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
+
+var rcustomProp = /^--/;
+
+
+var getStyles = function( elem ) {
+
+		// Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150)
+		// IE throws on elements created in popups
+		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
+		var view = elem.ownerDocument.defaultView;
+
+		if ( !view || !view.opener ) {
+			view = window;
+		}
+
+		return view.getComputedStyle( elem );
+	};
+
+var swap = function( elem, options, callback ) {
+	var ret, name,
+		old = {};
+
+	// Remember the old values, and insert the new ones
+	for ( name in options ) {
+		old[ name ] = elem.style[ name ];
+		elem.style[ name ] = options[ name ];
+	}
+
+	ret = callback.call( elem );
+
+	// Revert the old values
+	for ( name in options ) {
+		elem.style[ name ] = old[ name ];
+	}
+
+	return ret;
+};
+
+
+var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
+
+
+
+( function() {
+
+	// Executing both pixelPosition & boxSizingReliable tests require only one layout
+	// so they're executed at the same time to save the second computation.
+	function computeStyleTests() {
+
+		// This is a singleton, we need to execute it only once
+		if ( !div ) {
+			return;
+		}
+
+		container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
+			"margin-top:1px;padding:0;border:0";
+		div.style.cssText =
+			"position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
+			"margin:auto;border:1px;padding:1px;" +
+			"width:60%;top:1%";
+		documentElement.appendChild( container ).appendChild( div );
+
+		var divStyle = window.getComputedStyle( div );
+		pixelPositionVal = divStyle.top !== "1%";
+
+		// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
+		reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
+
+		// Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
+		// Some styles come back with percentage values, even though they shouldn't
+		div.style.right = "60%";
+		pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
+
+		// Support: IE 9 - 11 only
+		// Detect misreporting of content dimensions for box-sizing:border-box elements
+		boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
+
+		// Support: IE 9 only
+		// Detect overflow:scroll screwiness (gh-3699)
+		// Support: Chrome <=64
+		// Don't get tricked when zoom affects offsetWidth (gh-4029)
+		div.style.position = "absolute";
+		scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;
+
+		documentElement.removeChild( container );
+
+		// Nullify the div so it wouldn't be stored in the memory and
+		// it will also be a sign that checks already performed
+		div = null;
+	}
+
+	function roundPixelMeasures( measure ) {
+		return Math.round( parseFloat( measure ) );
+	}
+
+	var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
+		reliableTrDimensionsVal, reliableMarginLeftVal,
+		container = document.createElement( "div" ),
+		div = document.createElement( "div" );
+
+	// Finish early in limited (non-browser) environments
+	if ( !div.style ) {
+		return;
+	}
+
+	// Support: IE <=9 - 11 only
+	// Style of cloned element affects source element cloned (trac-8908)
+	div.style.backgroundClip = "content-box";
+	div.cloneNode( true ).style.backgroundClip = "";
+	support.clearCloneStyle = div.style.backgroundClip === "content-box";
+
+	jQuery.extend( support, {
+		boxSizingReliable: function() {
+			computeStyleTests();
+			return boxSizingReliableVal;
+		},
+		pixelBoxStyles: function() {
+			computeStyleTests();
+			return pixelBoxStylesVal;
+		},
+		pixelPosition: function() {
+			computeStyleTests();
+			return pixelPositionVal;
+		},
+		reliableMarginLeft: function() {
+			computeStyleTests();
+			return reliableMarginLeftVal;
+		},
+		scrollboxSize: function() {
+			computeStyleTests();
+			return scrollboxSizeVal;
+		},
+
+		// Support: IE 9 - 11+, Edge 15 - 18+
+		// IE/Edge misreport `getComputedStyle` of table rows with width/height
+		// set in CSS while `offset*` properties report correct values.
+		// Behavior in IE 9 is more subtle than in newer versions & it passes
+		// some versions of this test; make sure not to make it pass there!
+		//
+		// Support: Firefox 70+
+		// Only Firefox includes border widths
+		// in computed dimensions. (gh-4529)
+		reliableTrDimensions: function() {
+			var table, tr, trChild, trStyle;
+			if ( reliableTrDimensionsVal == null ) {
+				table = document.createElement( "table" );
+				tr = document.createElement( "tr" );
+				trChild = document.createElement( "div" );
+
+				table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate";
+				tr.style.cssText = "box-sizing:content-box;border:1px solid";
+
+				// Support: Chrome 86+
+				// Height set through cssText does not get applied.
+				// Computed height then comes back as 0.
+				tr.style.height = "1px";
+				trChild.style.height = "9px";
+
+				// Support: Android 8 Chrome 86+
+				// In our bodyBackground.html iframe,
+				// display for all div elements is set to "inline",
+				// which causes a problem only in Android 8 Chrome 86.
+				// Ensuring the div is `display: block`
+				// gets around this issue.
+				trChild.style.display = "block";
+
+				documentElement
+					.appendChild( table )
+					.appendChild( tr )
+					.appendChild( trChild );
+
+				trStyle = window.getComputedStyle( tr );
+				reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +
+					parseInt( trStyle.borderTopWidth, 10 ) +
+					parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;
+
+				documentElement.removeChild( table );
+			}
+			return reliableTrDimensionsVal;
+		}
+	} );
+} )();
+
+
+function curCSS( elem, name, computed ) {
+	var width, minWidth, maxWidth, ret,
+		isCustomProp = rcustomProp.test( name ),
+
+		// Support: Firefox 51+
+		// Retrieving style before computed somehow
+		// fixes an issue with getting wrong values
+		// on detached elements
+		style = elem.style;
+
+	computed = computed || getStyles( elem );
+
+	// getPropertyValue is needed for:
+	//   .css('filter') (IE 9 only, trac-12537)
+	//   .css('--customProperty) (gh-3144)
+	if ( computed ) {
+
+		// Support: IE <=9 - 11+
+		// IE only supports `"float"` in `getPropertyValue`; in computed styles
+		// it's only available as `"cssFloat"`. We no longer modify properties
+		// sent to `.css()` apart from camelCasing, so we need to check both.
+		// Normally, this would create difference in behavior: if
+		// `getPropertyValue` returns an empty string, the value returned
+		// by `.css()` would be `undefined`. This is usually the case for
+		// disconnected elements. However, in IE even disconnected elements
+		// with no styles return `"none"` for `getPropertyValue( "float" )`
+		ret = computed.getPropertyValue( name ) || computed[ name ];
+
+		if ( isCustomProp && ret ) {
+
+			// Support: Firefox 105+, Chrome <=105+
+			// Spec requires trimming whitespace for custom properties (gh-4926).
+			// Firefox only trims leading whitespace. Chrome just collapses
+			// both leading & trailing whitespace to a single space.
+			//
+			// Fall back to `undefined` if empty string returned.
+			// This collapses a missing definition with property defined
+			// and set to an empty string but there's no standard API
+			// allowing us to differentiate them without a performance penalty
+			// and returning `undefined` aligns with older jQuery.
+			//
+			// rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED
+			// as whitespace while CSS does not, but this is not a problem
+			// because CSS preprocessing replaces them with U+000A LINE FEED
+			// (which *is* CSS whitespace)
+			// https://www.w3.org/TR/css-syntax-3/#input-preprocessing
+			ret = ret.replace( rtrimCSS, "$1" ) || undefined;
+		}
+
+		if ( ret === "" && !isAttached( elem ) ) {
+			ret = jQuery.style( elem, name );
+		}
+
+		// A tribute to the "awesome hack by Dean Edwards"
+		// Android Browser returns percentage for some values,
+		// but width seems to be reliably pixels.
+		// This is against the CSSOM draft spec:
+		// https://drafts.csswg.org/cssom/#resolved-values
+		if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
+
+			// Remember the original values
+			width = style.width;
+			minWidth = style.minWidth;
+			maxWidth = style.maxWidth;
+
+			// Put in the new values to get a computed value out
+			style.minWidth = style.maxWidth = style.width = ret;
+			ret = computed.width;
+
+			// Revert the changed values
+			style.width = width;
+			style.minWidth = minWidth;
+			style.maxWidth = maxWidth;
+		}
+	}
+
+	return ret !== undefined ?
+
+		// Support: IE <=9 - 11 only
+		// IE returns zIndex value as an integer.
+		ret + "" :
+		ret;
+}
+
+
+function addGetHookIf( conditionFn, hookFn ) {
+
+	// Define the hook, we'll check on the first run if it's really needed.
+	return {
+		get: function() {
+			if ( conditionFn() ) {
+
+				// Hook not needed (or it's not possible to use it due
+				// to missing dependency), remove it.
+				delete this.get;
+				return;
+			}
+
+			// Hook needed; redefine it so that the support test is not executed again.
+			return ( this.get = hookFn ).apply( this, arguments );
+		}
+	};
+}
+
+
+var cssPrefixes = [ "Webkit", "Moz", "ms" ],
+	emptyStyle = document.createElement( "div" ).style,
+	vendorProps = {};
+
+// Return a vendor-prefixed property or undefined
+function vendorPropName( name ) {
+
+	// Check for vendor prefixed names
+	var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
+		i = cssPrefixes.length;
+
+	while ( i-- ) {
+		name = cssPrefixes[ i ] + capName;
+		if ( name in emptyStyle ) {
+			return name;
+		}
+	}
+}
+
+// Return a potentially-mapped jQuery.cssProps or vendor prefixed property
+function finalPropName( name ) {
+	var final = jQuery.cssProps[ name ] || vendorProps[ name ];
+
+	if ( final ) {
+		return final;
+	}
+	if ( name in emptyStyle ) {
+		return name;
+	}
+	return vendorProps[ name ] = vendorPropName( name ) || name;
+}
+
+
+var
+
+	// Swappable if display is none or starts with table
+	// except "table", "table-cell", or "table-caption"
+	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
+	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
+	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
+	cssNormalTransform = {
+		letterSpacing: "0",
+		fontWeight: "400"
+	};
+
+function setPositiveNumber( _elem, value, subtract ) {
+
+	// Any relative (+/-) values have already been
+	// normalized at this point
+	var matches = rcssNum.exec( value );
+	return matches ?
+
+		// Guard against undefined "subtract", e.g., when used as in cssHooks
+		Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
+		value;
+}
+
+function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
+	var i = dimension === "width" ? 1 : 0,
+		extra = 0,
+		delta = 0,
+		marginDelta = 0;
+
+	// Adjustment may not be necessary
+	if ( box === ( isBorderBox ? "border" : "content" ) ) {
+		return 0;
+	}
+
+	for ( ; i < 4; i += 2 ) {
+
+		// Both box models exclude margin
+		// Count margin delta separately to only add it after scroll gutter adjustment.
+		// This is needed to make negative margins work with `outerHeight( true )` (gh-3982).
+		if ( box === "margin" ) {
+			marginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
+		}
+
+		// If we get here with a content-box, we're seeking "padding" or "border" or "margin"
+		if ( !isBorderBox ) {
+
+			// Add padding
+			delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+
+			// For "border" or "margin", add border
+			if ( box !== "padding" ) {
+				delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+
+			// But still keep track of it otherwise
+			} else {
+				extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+			}
+
+		// If we get here with a border-box (content + padding + border), we're seeking "content" or
+		// "padding" or "margin"
+		} else {
+
+			// For "content", subtract padding
+			if ( box === "content" ) {
+				delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
+			}
+
+			// For "content" or "padding", subtract border
+			if ( box !== "margin" ) {
+				delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
+			}
+		}
+	}
+
+	// Account for positive content-box scroll gutter when requested by providing computedVal
+	if ( !isBorderBox && computedVal >= 0 ) {
+
+		// offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
+		// Assuming integer scroll gutter, subtract the rest and round down
+		delta += Math.max( 0, Math.ceil(
+			elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
+			computedVal -
+			delta -
+			extra -
+			0.5
+
+		// If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
+		// Use an explicit zero to avoid NaN (gh-3964)
+		) ) || 0;
+	}
+
+	return delta + marginDelta;
+}
+
+function getWidthOrHeight( elem, dimension, extra ) {
+
+	// Start with computed style
+	var styles = getStyles( elem ),
+
+		// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
+		// Fake content-box until we know it's needed to know the true value.
+		boxSizingNeeded = !support.boxSizingReliable() || extra,
+		isBorderBox = boxSizingNeeded &&
+			jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
+		valueIsBorderBox = isBorderBox,
+
+		val = curCSS( elem, dimension, styles ),
+		offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );
+
+	// Support: Firefox <=54
+	// Return a confounding non-pixel value or feign ignorance, as appropriate.
+	if ( rnumnonpx.test( val ) ) {
+		if ( !extra ) {
+			return val;
+		}
+		val = "auto";
+	}
+
+
+	// Support: IE 9 - 11 only
+	// Use offsetWidth/offsetHeight for when box sizing is unreliable.
+	// In those cases, the computed value can be trusted to be border-box.
+	if ( ( !support.boxSizingReliable() && isBorderBox ||
+
+		// Support: IE 10 - 11+, Edge 15 - 18+
+		// IE/Edge misreport `getComputedStyle` of table rows with width/height
+		// set in CSS while `offset*` properties report correct values.
+		// Interestingly, in some cases IE 9 doesn't suffer from this issue.
+		!support.reliableTrDimensions() && nodeName( elem, "tr" ) ||
+
+		// Fall back to offsetWidth/offsetHeight when value is "auto"
+		// This happens for inline elements with no explicit setting (gh-3571)
+		val === "auto" ||
+
+		// Support: Android <=4.1 - 4.3 only
+		// Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
+		!parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&
+
+		// Make sure the element is visible & connected
+		elem.getClientRects().length ) {
+
+		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
+
+		// Where available, offsetWidth/offsetHeight approximate border box dimensions.
+		// Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
+		// retrieved value as a content box dimension.
+		valueIsBorderBox = offsetProp in elem;
+		if ( valueIsBorderBox ) {
+			val = elem[ offsetProp ];
+		}
+	}
+
+	// Normalize "" and auto
+	val = parseFloat( val ) || 0;
+
+	// Adjust for the element's box model
+	return ( val +
+		boxModelAdjustment(
+			elem,
+			dimension,
+			extra || ( isBorderBox ? "border" : "content" ),
+			valueIsBorderBox,
+			styles,
+
+			// Provide the current computed size to request scroll gutter calculation (gh-3589)
+			val
+		)
+	) + "px";
+}
+
+jQuery.extend( {
+
+	// Add in style property hooks for overriding the default
+	// behavior of getting and setting a style property
+	cssHooks: {
+		opacity: {
+			get: function( elem, computed ) {
+				if ( computed ) {
+
+					// We should always get a number back from opacity
+					var ret = curCSS( elem, "opacity" );
+					return ret === "" ? "1" : ret;
+				}
+			}
+		}
+	},
+
+	// Don't automatically add "px" to these possibly-unitless properties
+	cssNumber: {
+		animationIterationCount: true,
+		aspectRatio: true,
+		borderImageSlice: true,
+		columnCount: true,
+		flexGrow: true,
+		flexShrink: true,
+		fontWeight: true,
+		gridArea: true,
+		gridColumn: true,
+		gridColumnEnd: true,
+		gridColumnStart: true,
+		gridRow: true,
+		gridRowEnd: true,
+		gridRowStart: true,
+		lineHeight: true,
+		opacity: true,
+		order: true,
+		orphans: true,
+		scale: true,
+		widows: true,
+		zIndex: true,
+		zoom: true,
+
+		// SVG-related
+		fillOpacity: true,
+		floodOpacity: true,
+		stopOpacity: true,
+		strokeMiterlimit: true,
+		strokeOpacity: true
+	},
+
+	// Add in properties whose names you wish to fix before
+	// setting or getting the value
+	cssProps: {},
+
+	// Get and set the style property on a DOM Node
+	style: function( elem, name, value, extra ) {
+
+		// Don't set styles on text and comment nodes
+		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
+			return;
+		}
+
+		// Make sure that we're working with the right name
+		var ret, type, hooks,
+			origName = camelCase( name ),
+			isCustomProp = rcustomProp.test( name ),
+			style = elem.style;
+
+		// Make sure that we're working with the right name. We don't
+		// want to query the value if it is a CSS custom property
+		// since they are user-defined.
+		if ( !isCustomProp ) {
+			name = finalPropName( origName );
+		}
+
+		// Gets hook for the prefixed version, then unprefixed version
+		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+		// Check if we're setting a value
+		if ( value !== undefined ) {
+			type = typeof value;
+
+			// Convert "+=" or "-=" to relative numbers (trac-7345)
+			if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
+				value = adjustCSS( elem, name, ret );
+
+				// Fixes bug trac-9237
+				type = "number";
+			}
+
+			// Make sure that null and NaN values aren't set (trac-7116)
+			if ( value == null || value !== value ) {
+				return;
+			}
+
+			// If a number was passed in, add the unit (except for certain CSS properties)
+			// The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
+			// "px" to a few hardcoded values.
+			if ( type === "number" && !isCustomProp ) {
+				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
+			}
+
+			// background-* props affect original clone's values
+			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
+				style[ name ] = "inherit";
+			}
+
+			// If a hook was provided, use that value, otherwise just set the specified value
+			if ( !hooks || !( "set" in hooks ) ||
+				( value = hooks.set( elem, value, extra ) ) !== undefined ) {
+
+				if ( isCustomProp ) {
+					style.setProperty( name, value );
+				} else {
+					style[ name ] = value;
+				}
+			}
+
+		} else {
+
+			// If a hook was provided get the non-computed value from there
+			if ( hooks && "get" in hooks &&
+				( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
+
+				return ret;
+			}
+
+			// Otherwise just get the value from the style object
+			return style[ name ];
+		}
+	},
+
+	css: function( elem, name, extra, styles ) {
+		var val, num, hooks,
+			origName = camelCase( name ),
+			isCustomProp = rcustomProp.test( name );
+
+		// Make sure that we're working with the right name. We don't
+		// want to modify the value if it is a CSS custom property
+		// since they are user-defined.
+		if ( !isCustomProp ) {
+			name = finalPropName( origName );
+		}
+
+		// Try prefixed name followed by the unprefixed name
+		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
+
+		// If a hook was provided get the computed value from there
+		if ( hooks && "get" in hooks ) {
+			val = hooks.get( elem, true, extra );
+		}
+
+		// Otherwise, if a way to get the computed value exists, use that
+		if ( val === undefined ) {
+			val = curCSS( elem, name, styles );
+		}
+
+		// Convert "normal" to computed value
+		if ( val === "normal" && name in cssNormalTransform ) {
+			val = cssNormalTransform[ name ];
+		}
+
+		// Make numeric if forced or a qualifier was provided and val looks numeric
+		if ( extra === "" || extra ) {
+			num = parseFloat( val );
+			return extra === true || isFinite( num ) ? num || 0 : val;
+		}
+
+		return val;
+	}
+} );
+
+jQuery.each( [ "height", "width" ], function( _i, dimension ) {
+	jQuery.cssHooks[ dimension ] = {
+		get: function( elem, computed, extra ) {
+			if ( computed ) {
+
+				// Certain elements can have dimension info if we invisibly show them
+				// but it must have a current display style that would benefit
+				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
+
+					// Support: Safari 8+
+					// Table columns in Safari have non-zero offsetWidth & zero
+					// getBoundingClientRect().width unless display is changed.
+					// Support: IE <=11 only
+					// Running getBoundingClientRect on a disconnected node
+					// in IE throws an error.
+					( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
+					swap( elem, cssShow, function() {
+						return getWidthOrHeight( elem, dimension, extra );
+					} ) :
+					getWidthOrHeight( elem, dimension, extra );
+			}
+		},
+
+		set: function( elem, value, extra ) {
+			var matches,
+				styles = getStyles( elem ),
+
+				// Only read styles.position if the test has a chance to fail
+				// to avoid forcing a reflow.
+				scrollboxSizeBuggy = !support.scrollboxSize() &&
+					styles.position === "absolute",
+
+				// To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
+				boxSizingNeeded = scrollboxSizeBuggy || extra,
+				isBorderBox = boxSizingNeeded &&
+					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
+				subtract = extra ?
+					boxModelAdjustment(
+						elem,
+						dimension,
+						extra,
+						isBorderBox,
+						styles
+					) :
+					0;
+
+			// Account for unreliable border-box dimensions by comparing offset* to computed and
+			// faking a content-box to get border and padding (gh-3699)
+			if ( isBorderBox && scrollboxSizeBuggy ) {
+				subtract -= Math.ceil(
+					elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
+					parseFloat( styles[ dimension ] ) -
+					boxModelAdjustment( elem, dimension, "border", false, styles ) -
+					0.5
+				);
+			}
+
+			// Convert to pixels if value adjustment is needed
+			if ( subtract && ( matches = rcssNum.exec( value ) ) &&
+				( matches[ 3 ] || "px" ) !== "px" ) {
+
+				elem.style[ dimension ] = value;
+				value = jQuery.css( elem, dimension );
+			}
+
+			return setPositiveNumber( elem, value, subtract );
+		}
+	};
+} );
+
+jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
+	function( elem, computed ) {
+		if ( computed ) {
+			return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
+				elem.getBoundingClientRect().left -
+					swap( elem, { marginLeft: 0 }, function() {
+						return elem.getBoundingClientRect().left;
+					} )
+			) + "px";
+		}
+	}
+);
+
+// These hooks are used by animate to expand properties
+jQuery.each( {
+	margin: "",
+	padding: "",
+	border: "Width"
+}, function( prefix, suffix ) {
+	jQuery.cssHooks[ prefix + suffix ] = {
+		expand: function( value ) {
+			var i = 0,
+				expanded = {},
+
+				// Assumes a single number if not a string
+				parts = typeof value === "string" ? value.split( " " ) : [ value ];
+
+			for ( ; i < 4; i++ ) {
+				expanded[ prefix + cssExpand[ i ] + suffix ] =
+					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
+			}
+
+			return expanded;
+		}
+	};
+
+	if ( prefix !== "margin" ) {
+		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
+	}
+} );
+
+jQuery.fn.extend( {
+	css: function( name, value ) {
+		return access( this, function( elem, name, value ) {
+			var styles, len,
+				map = {},
+				i = 0;
+
+			if ( Array.isArray( name ) ) {
+				styles = getStyles( elem );
+				len = name.length;
+
+				for ( ; i < len; i++ ) {
+					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
+				}
+
+				return map;
+			}
+
+			return value !== undefined ?
+				jQuery.style( elem, name, value ) :
+				jQuery.css( elem, name );
+		}, name, value, arguments.length > 1 );
+	}
+} );
+
+
+function Tween( elem, options, prop, end, easing ) {
+	return new Tween.prototype.init( elem, options, prop, end, easing );
+}
+jQuery.Tween = Tween;
+
+Tween.prototype = {
+	constructor: Tween,
+	init: function( elem, options, prop, end, easing, unit ) {
+		this.elem = elem;
+		this.prop = prop;
+		this.easing = easing || jQuery.easing._default;
+		this.options = options;
+		this.start = this.now = this.cur();
+		this.end = end;
+		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
+	},
+	cur: function() {
+		var hooks = Tween.propHooks[ this.prop ];
+
+		return hooks && hooks.get ?
+			hooks.get( this ) :
+			Tween.propHooks._default.get( this );
+	},
+	run: function( percent ) {
+		var eased,
+			hooks = Tween.propHooks[ this.prop ];
+
+		if ( this.options.duration ) {
+			this.pos = eased = jQuery.easing[ this.easing ](
+				percent, this.options.duration * percent, 0, 1, this.options.duration
+			);
+		} else {
+			this.pos = eased = percent;
+		}
+		this.now = ( this.end - this.start ) * eased + this.start;
+
+		if ( this.options.step ) {
+			this.options.step.call( this.elem, this.now, this );
+		}
+
+		if ( hooks && hooks.set ) {
+			hooks.set( this );
+		} else {
+			Tween.propHooks._default.set( this );
+		}
+		return this;
+	}
+};
+
+Tween.prototype.init.prototype = Tween.prototype;
+
+Tween.propHooks = {
+	_default: {
+		get: function( tween ) {
+			var result;
+
+			// Use a property on the element directly when it is not a DOM element,
+			// or when there is no matching style property that exists.
+			if ( tween.elem.nodeType !== 1 ||
+				tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
+				return tween.elem[ tween.prop ];
+			}
+
+			// Passing an empty string as a 3rd parameter to .css will automatically
+			// attempt a parseFloat and fallback to a string if the parse fails.
+			// Simple values such as "10px" are parsed to Float;
+			// complex values such as "rotate(1rad)" are returned as-is.
+			result = jQuery.css( tween.elem, tween.prop, "" );
+
+			// Empty strings, null, undefined and "auto" are converted to 0.
+			return !result || result === "auto" ? 0 : result;
+		},
+		set: function( tween ) {
+
+			// Use step hook for back compat.
+			// Use cssHook if its there.
+			// Use .style if available and use plain properties where available.
+			if ( jQuery.fx.step[ tween.prop ] ) {
+				jQuery.fx.step[ tween.prop ]( tween );
+			} else if ( tween.elem.nodeType === 1 && (
+				jQuery.cssHooks[ tween.prop ] ||
+					tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {
+				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
+			} else {
+				tween.elem[ tween.prop ] = tween.now;
+			}
+		}
+	}
+};
+
+// Support: IE <=9 only
+// Panic based approach to setting things on disconnected nodes
+Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
+	set: function( tween ) {
+		if ( tween.elem.nodeType && tween.elem.parentNode ) {
+			tween.elem[ tween.prop ] = tween.now;
+		}
+	}
+};
+
+jQuery.easing = {
+	linear: function( p ) {
+		return p;
+	},
+	swing: function( p ) {
+		return 0.5 - Math.cos( p * Math.PI ) / 2;
+	},
+	_default: "swing"
+};
+
+jQuery.fx = Tween.prototype.init;
+
+// Back compat <1.8 extension point
+jQuery.fx.step = {};
+
+
+
+
+var
+	fxNow, inProgress,
+	rfxtypes = /^(?:toggle|show|hide)$/,
+	rrun = /queueHooks$/;
+
+function schedule() {
+	if ( inProgress ) {
+		if ( document.hidden === false && window.requestAnimationFrame ) {
+			window.requestAnimationFrame( schedule );
+		} else {
+			window.setTimeout( schedule, jQuery.fx.interval );
+		}
+
+		jQuery.fx.tick();
+	}
+}
+
+// Animations created synchronously will run synchronously
+function createFxNow() {
+	window.setTimeout( function() {
+		fxNow = undefined;
+	} );
+	return ( fxNow = Date.now() );
+}
+
+// Generate parameters to create a standard animation
+function genFx( type, includeWidth ) {
+	var which,
+		i = 0,
+		attrs = { height: type };
+
+	// If we include width, step value is 1 to do all cssExpand values,
+	// otherwise step value is 2 to skip over Left and Right
+	includeWidth = includeWidth ? 1 : 0;
+	for ( ; i < 4; i += 2 - includeWidth ) {
+		which = cssExpand[ i ];
+		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
+	}
+
+	if ( includeWidth ) {
+		attrs.opacity = attrs.width = type;
+	}
+
+	return attrs;
+}
+
+function createTween( value, prop, animation ) {
+	var tween,
+		collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
+		index = 0,
+		length = collection.length;
+	for ( ; index < length; index++ ) {
+		if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
+
+			// We're done with this property
+			return tween;
+		}
+	}
+}
+
+function defaultPrefilter( elem, props, opts ) {
+	var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
+		isBox = "width" in props || "height" in props,
+		anim = this,
+		orig = {},
+		style = elem.style,
+		hidden = elem.nodeType && isHiddenWithinTree( elem ),
+		dataShow = dataPriv.get( elem, "fxshow" );
+
+	// Queue-skipping animations hijack the fx hooks
+	if ( !opts.queue ) {
+		hooks = jQuery._queueHooks( elem, "fx" );
+		if ( hooks.unqueued == null ) {
+			hooks.unqueued = 0;
+			oldfire = hooks.empty.fire;
+			hooks.empty.fire = function() {
+				if ( !hooks.unqueued ) {
+					oldfire();
+				}
+			};
+		}
+		hooks.unqueued++;
+
+		anim.always( function() {
+
+			// Ensure the complete handler is called before this completes
+			anim.always( function() {
+				hooks.unqueued--;
+				if ( !jQuery.queue( elem, "fx" ).length ) {
+					hooks.empty.fire();
+				}
+			} );
+		} );
+	}
+
+	// Detect show/hide animations
+	for ( prop in props ) {
+		value = props[ prop ];
+		if ( rfxtypes.test( value ) ) {
+			delete props[ prop ];
+			toggle = toggle || value === "toggle";
+			if ( value === ( hidden ? "hide" : "show" ) ) {
+
+				// Pretend to be hidden if this is a "show" and
+				// there is still data from a stopped show/hide
+				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
+					hidden = true;
+
+				// Ignore all other no-op show/hide data
+				} else {
+					continue;
+				}
+			}
+			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
+		}
+	}
+
+	// Bail out if this is a no-op like .hide().hide()
+	propTween = !jQuery.isEmptyObject( props );
+	if ( !propTween && jQuery.isEmptyObject( orig ) ) {
+		return;
+	}
+
+	// Restrict "overflow" and "display" styles during box animations
+	if ( isBox && elem.nodeType === 1 ) {
+
+		// Support: IE <=9 - 11, Edge 12 - 15
+		// Record all 3 overflow attributes because IE does not infer the shorthand
+		// from identically-valued overflowX and overflowY and Edge just mirrors
+		// the overflowX value there.
+		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
+
+		// Identify a display type, preferring old show/hide data over the CSS cascade
+		restoreDisplay = dataShow && dataShow.display;
+		if ( restoreDisplay == null ) {
+			restoreDisplay = dataPriv.get( elem, "display" );
+		}
+		display = jQuery.css( elem, "display" );
+		if ( display === "none" ) {
+			if ( restoreDisplay ) {
+				display = restoreDisplay;
+			} else {
+
+				// Get nonempty value(s) by temporarily forcing visibility
+				showHide( [ elem ], true );
+				restoreDisplay = elem.style.display || restoreDisplay;
+				display = jQuery.css( elem, "display" );
+				showHide( [ elem ] );
+			}
+		}
+
+		// Animate inline elements as inline-block
+		if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
+			if ( jQuery.css( elem, "float" ) === "none" ) {
+
+				// Restore the original display value at the end of pure show/hide animations
+				if ( !propTween ) {
+					anim.done( function() {
+						style.display = restoreDisplay;
+					} );
+					if ( restoreDisplay == null ) {
+						display = style.display;
+						restoreDisplay = display === "none" ? "" : display;
+					}
+				}
+				style.display = "inline-block";
+			}
+		}
+	}
+
+	if ( opts.overflow ) {
+		style.overflow = "hidden";
+		anim.always( function() {
+			style.overflow = opts.overflow[ 0 ];
+			style.overflowX = opts.overflow[ 1 ];
+			style.overflowY = opts.overflow[ 2 ];
+		} );
+	}
+
+	// Implement show/hide animations
+	propTween = false;
+	for ( prop in orig ) {
+
+		// General show/hide setup for this element animation
+		if ( !propTween ) {
+			if ( dataShow ) {
+				if ( "hidden" in dataShow ) {
+					hidden = dataShow.hidden;
+				}
+			} else {
+				dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
+			}
+
+			// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
+			if ( toggle ) {
+				dataShow.hidden = !hidden;
+			}
+
+			// Show elements before animating them
+			if ( hidden ) {
+				showHide( [ elem ], true );
+			}
+
+			/* eslint-disable no-loop-func */
+
+			anim.done( function() {
+
+				/* eslint-enable no-loop-func */
+
+				// The final step of a "hide" animation is actually hiding the element
+				if ( !hidden ) {
+					showHide( [ elem ] );
+				}
+				dataPriv.remove( elem, "fxshow" );
+				for ( prop in orig ) {
+					jQuery.style( elem, prop, orig[ prop ] );
+				}
+			} );
+		}
+
+		// Per-property setup
+		propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
+		if ( !( prop in dataShow ) ) {
+			dataShow[ prop ] = propTween.start;
+			if ( hidden ) {
+				propTween.end = propTween.start;
+				propTween.start = 0;
+			}
+		}
+	}
+}
+
+function propFilter( props, specialEasing ) {
+	var index, name, easing, value, hooks;
+
+	// camelCase, specialEasing and expand cssHook pass
+	for ( index in props ) {
+		name = camelCase( index );
+		easing = specialEasing[ name ];
+		value = props[ index ];
+		if ( Array.isArray( value ) ) {
+			easing = value[ 1 ];
+			value = props[ index ] = value[ 0 ];
+		}
+
+		if ( index !== name ) {
+			props[ name ] = value;
+			delete props[ index ];
+		}
+
+		hooks = jQuery.cssHooks[ name ];
+		if ( hooks && "expand" in hooks ) {
+			value = hooks.expand( value );
+			delete props[ name ];
+
+			// Not quite $.extend, this won't overwrite existing keys.
+			// Reusing 'index' because we have the correct "name"
+			for ( index in value ) {
+				if ( !( index in props ) ) {
+					props[ index ] = value[ index ];
+					specialEasing[ index ] = easing;
+				}
+			}
+		} else {
+			specialEasing[ name ] = easing;
+		}
+	}
+}
+
+function Animation( elem, properties, options ) {
+	var result,
+		stopped,
+		index = 0,
+		length = Animation.prefilters.length,
+		deferred = jQuery.Deferred().always( function() {
+
+			// Don't match elem in the :animated selector
+			delete tick.elem;
+		} ),
+		tick = function() {
+			if ( stopped ) {
+				return false;
+			}
+			var currentTime = fxNow || createFxNow(),
+				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
+
+				// Support: Android 2.3 only
+				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497)
+				temp = remaining / animation.duration || 0,
+				percent = 1 - temp,
+				index = 0,
+				length = animation.tweens.length;
+
+			for ( ; index < length; index++ ) {
+				animation.tweens[ index ].run( percent );
+			}
+
+			deferred.notifyWith( elem, [ animation, percent, remaining ] );
+
+			// If there's more to do, yield
+			if ( percent < 1 && length ) {
+				return remaining;
+			}
+
+			// If this was an empty animation, synthesize a final progress notification
+			if ( !length ) {
+				deferred.notifyWith( elem, [ animation, 1, 0 ] );
+			}
+
+			// Resolve the animation and report its conclusion
+			deferred.resolveWith( elem, [ animation ] );
+			return false;
+		},
+		animation = deferred.promise( {
+			elem: elem,
+			props: jQuery.extend( {}, properties ),
+			opts: jQuery.extend( true, {
+				specialEasing: {},
+				easing: jQuery.easing._default
+			}, options ),
+			originalProperties: properties,
+			originalOptions: options,
+			startTime: fxNow || createFxNow(),
+			duration: options.duration,
+			tweens: [],
+			createTween: function( prop, end ) {
+				var tween = jQuery.Tween( elem, animation.opts, prop, end,
+					animation.opts.specialEasing[ prop ] || animation.opts.easing );
+				animation.tweens.push( tween );
+				return tween;
+			},
+			stop: function( gotoEnd ) {
+				var index = 0,
+
+					// If we are going to the end, we want to run all the tweens
+					// otherwise we skip this part
+					length = gotoEnd ? animation.tweens.length : 0;
+				if ( stopped ) {
+					return this;
+				}
+				stopped = true;
+				for ( ; index < length; index++ ) {
+					animation.tweens[ index ].run( 1 );
+				}
+
+				// Resolve when we played the last frame; otherwise, reject
+				if ( gotoEnd ) {
+					deferred.notifyWith( elem, [ animation, 1, 0 ] );
+					deferred.resolveWith( elem, [ animation, gotoEnd ] );
+				} else {
+					deferred.rejectWith( elem, [ animation, gotoEnd ] );
+				}
+				return this;
+			}
+		} ),
+		props = animation.props;
+
+	propFilter( props, animation.opts.specialEasing );
+
+	for ( ; index < length; index++ ) {
+		result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
+		if ( result ) {
+			if ( isFunction( result.stop ) ) {
+				jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
+					result.stop.bind( result );
+			}
+			return result;
+		}
+	}
+
+	jQuery.map( props, createTween, animation );
+
+	if ( isFunction( animation.opts.start ) ) {
+		animation.opts.start.call( elem, animation );
+	}
+
+	// Attach callbacks from options
+	animation
+		.progress( animation.opts.progress )
+		.done( animation.opts.done, animation.opts.complete )
+		.fail( animation.opts.fail )
+		.always( animation.opts.always );
+
+	jQuery.fx.timer(
+		jQuery.extend( tick, {
+			elem: elem,
+			anim: animation,
+			queue: animation.opts.queue
+		} )
+	);
+
+	return animation;
+}
+
+jQuery.Animation = jQuery.extend( Animation, {
+
+	tweeners: {
+		"*": [ function( prop, value ) {
+			var tween = this.createTween( prop, value );
+			adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
+			return tween;
+		} ]
+	},
+
+	tweener: function( props, callback ) {
+		if ( isFunction( props ) ) {
+			callback = props;
+			props = [ "*" ];
+		} else {
+			props = props.match( rnothtmlwhite );
+		}
+
+		var prop,
+			index = 0,
+			length = props.length;
+
+		for ( ; index < length; index++ ) {
+			prop = props[ index ];
+			Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
+			Animation.tweeners[ prop ].unshift( callback );
+		}
+	},
+
+	prefilters: [ defaultPrefilter ],
+
+	prefilter: function( callback, prepend ) {
+		if ( prepend ) {
+			Animation.prefilters.unshift( callback );
+		} else {
+			Animation.prefilters.push( callback );
+		}
+	}
+} );
+
+jQuery.speed = function( speed, easing, fn ) {
+	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
+		complete: fn || !fn && easing ||
+			isFunction( speed ) && speed,
+		duration: speed,
+		easing: fn && easing || easing && !isFunction( easing ) && easing
+	};
+
+	// Go to the end state if fx are off
+	if ( jQuery.fx.off ) {
+		opt.duration = 0;
+
+	} else {
+		if ( typeof opt.duration !== "number" ) {
+			if ( opt.duration in jQuery.fx.speeds ) {
+				opt.duration = jQuery.fx.speeds[ opt.duration ];
+
+			} else {
+				opt.duration = jQuery.fx.speeds._default;
+			}
+		}
+	}
+
+	// Normalize opt.queue - true/undefined/null -> "fx"
+	if ( opt.queue == null || opt.queue === true ) {
+		opt.queue = "fx";
+	}
+
+	// Queueing
+	opt.old = opt.complete;
+
+	opt.complete = function() {
+		if ( isFunction( opt.old ) ) {
+			opt.old.call( this );
+		}
+
+		if ( opt.queue ) {
+			jQuery.dequeue( this, opt.queue );
+		}
+	};
+
+	return opt;
+};
+
+jQuery.fn.extend( {
+	fadeTo: function( speed, to, easing, callback ) {
+
+		// Show any hidden elements after setting opacity to 0
+		return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
+
+			// Animate to the value specified
+			.end().animate( { opacity: to }, speed, easing, callback );
+	},
+	animate: function( prop, speed, easing, callback ) {
+		var empty = jQuery.isEmptyObject( prop ),
+			optall = jQuery.speed( speed, easing, callback ),
+			doAnimation = function() {
+
+				// Operate on a copy of prop so per-property easing won't be lost
+				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
+
+				// Empty animations, or finishing resolves immediately
+				if ( empty || dataPriv.get( this, "finish" ) ) {
+					anim.stop( true );
+				}
+			};
+
+		doAnimation.finish = doAnimation;
+
+		return empty || optall.queue === false ?
+			this.each( doAnimation ) :
+			this.queue( optall.queue, doAnimation );
+	},
+	stop: function( type, clearQueue, gotoEnd ) {
+		var stopQueue = function( hooks ) {
+			var stop = hooks.stop;
+			delete hooks.stop;
+			stop( gotoEnd );
+		};
+
+		if ( typeof type !== "string" ) {
+			gotoEnd = clearQueue;
+			clearQueue = type;
+			type = undefined;
+		}
+		if ( clearQueue ) {
+			this.queue( type || "fx", [] );
+		}
+
+		return this.each( function() {
+			var dequeue = true,
+				index = type != null && type + "queueHooks",
+				timers = jQuery.timers,
+				data = dataPriv.get( this );
+
+			if ( index ) {
+				if ( data[ index ] && data[ index ].stop ) {
+					stopQueue( data[ index ] );
+				}
+			} else {
+				for ( index in data ) {
+					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
+						stopQueue( data[ index ] );
+					}
+				}
+			}
+
+			for ( index = timers.length; index--; ) {
+				if ( timers[ index ].elem === this &&
+					( type == null || timers[ index ].queue === type ) ) {
+
+					timers[ index ].anim.stop( gotoEnd );
+					dequeue = false;
+					timers.splice( index, 1 );
+				}
+			}
+
+			// Start the next in the queue if the last step wasn't forced.
+			// Timers currently will call their complete callbacks, which
+			// will dequeue but only if they were gotoEnd.
+			if ( dequeue || !gotoEnd ) {
+				jQuery.dequeue( this, type );
+			}
+		} );
+	},
+	finish: function( type ) {
+		if ( type !== false ) {
+			type = type || "fx";
+		}
+		return this.each( function() {
+			var index,
+				data = dataPriv.get( this ),
+				queue = data[ type + "queue" ],
+				hooks = data[ type + "queueHooks" ],
+				timers = jQuery.timers,
+				length = queue ? queue.length : 0;
+
+			// Enable finishing flag on private data
+			data.finish = true;
+
+			// Empty the queue first
+			jQuery.queue( this, type, [] );
+
+			if ( hooks && hooks.stop ) {
+				hooks.stop.call( this, true );
+			}
+
+			// Look for any active animations, and finish them
+			for ( index = timers.length; index--; ) {
+				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
+					timers[ index ].anim.stop( true );
+					timers.splice( index, 1 );
+				}
+			}
+
+			// Look for any animations in the old queue and finish them
+			for ( index = 0; index < length; index++ ) {
+				if ( queue[ index ] && queue[ index ].finish ) {
+					queue[ index ].finish.call( this );
+				}
+			}
+
+			// Turn off finishing flag
+			delete data.finish;
+		} );
+	}
+} );
+
+jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) {
+	var cssFn = jQuery.fn[ name ];
+	jQuery.fn[ name ] = function( speed, easing, callback ) {
+		return speed == null || typeof speed === "boolean" ?
+			cssFn.apply( this, arguments ) :
+			this.animate( genFx( name, true ), speed, easing, callback );
+	};
+} );
+
+// Generate shortcuts for custom animations
+jQuery.each( {
+	slideDown: genFx( "show" ),
+	slideUp: genFx( "hide" ),
+	slideToggle: genFx( "toggle" ),
+	fadeIn: { opacity: "show" },
+	fadeOut: { opacity: "hide" },
+	fadeToggle: { opacity: "toggle" }
+}, function( name, props ) {
+	jQuery.fn[ name ] = function( speed, easing, callback ) {
+		return this.animate( props, speed, easing, callback );
+	};
+} );
+
+jQuery.timers = [];
+jQuery.fx.tick = function() {
+	var timer,
+		i = 0,
+		timers = jQuery.timers;
+
+	fxNow = Date.now();
+
+	for ( ; i < timers.length; i++ ) {
+		timer = timers[ i ];
+
+		// Run the timer and safely remove it when done (allowing for external removal)
+		if ( !timer() && timers[ i ] === timer ) {
+			timers.splice( i--, 1 );
+		}
+	}
+
+	if ( !timers.length ) {
+		jQuery.fx.stop();
+	}
+	fxNow = undefined;
+};
+
+jQuery.fx.timer = function( timer ) {
+	jQuery.timers.push( timer );
+	jQuery.fx.start();
+};
+
+jQuery.fx.interval = 13;
+jQuery.fx.start = function() {
+	if ( inProgress ) {
+		return;
+	}
+
+	inProgress = true;
+	schedule();
+};
+
+jQuery.fx.stop = function() {
+	inProgress = null;
+};
+
+jQuery.fx.speeds = {
+	slow: 600,
+	fast: 200,
+
+	// Default speed
+	_default: 400
+};
+
+
+// Based off of the plugin by Clint Helfers, with permission.
+jQuery.fn.delay = function( time, type ) {
+	time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
+	type = type || "fx";
+
+	return this.queue( type, function( next, hooks ) {
+		var timeout = window.setTimeout( next, time );
+		hooks.stop = function() {
+			window.clearTimeout( timeout );
+		};
+	} );
+};
+
+
+( function() {
+	var input = document.createElement( "input" ),
+		select = document.createElement( "select" ),
+		opt = select.appendChild( document.createElement( "option" ) );
+
+	input.type = "checkbox";
+
+	// Support: Android <=4.3 only
+	// Default value for a checkbox should be "on"
+	support.checkOn = input.value !== "";
+
+	// Support: IE <=11 only
+	// Must access selectedIndex to make default options select
+	support.optSelected = opt.selected;
+
+	// Support: IE <=11 only
+	// An input loses its value after becoming a radio
+	input = document.createElement( "input" );
+	input.value = "t";
+	input.type = "radio";
+	support.radioValue = input.value === "t";
+} )();
+
+
+var boolHook,
+	attrHandle = jQuery.expr.attrHandle;
+
+jQuery.fn.extend( {
+	attr: function( name, value ) {
+		return access( this, jQuery.attr, name, value, arguments.length > 1 );
+	},
+
+	removeAttr: function( name ) {
+		return this.each( function() {
+			jQuery.removeAttr( this, name );
+		} );
+	}
+} );
+
+jQuery.extend( {
+	attr: function( elem, name, value ) {
+		var ret, hooks,
+			nType = elem.nodeType;
+
+		// Don't get/set attributes on text, comment and attribute nodes
+		if ( nType === 3 || nType === 8 || nType === 2 ) {
+			return;
+		}
+
+		// Fallback to prop when attributes are not supported
+		if ( typeof elem.getAttribute === "undefined" ) {
+			return jQuery.prop( elem, name, value );
+		}
+
+		// Attribute hooks are determined by the lowercase version
+		// Grab necessary hook if one is defined
+		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
+			hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
+				( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
+		}
+
+		if ( value !== undefined ) {
+			if ( value === null ) {
+				jQuery.removeAttr( elem, name );
+				return;
+			}
+
+			if ( hooks && "set" in hooks &&
+				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
+				return ret;
+			}
+
+			elem.setAttribute( name, value + "" );
+			return value;
+		}
+
+		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
+			return ret;
+		}
+
+		ret = jQuery.find.attr( elem, name );
+
+		// Non-existent attributes return null, we normalize to undefined
+		return ret == null ? undefined : ret;
+	},
+
+	attrHooks: {
+		type: {
+			set: function( elem, value ) {
+				if ( !support.radioValue && value === "radio" &&
+					nodeName( elem, "input" ) ) {
+					var val = elem.value;
+					elem.setAttribute( "type", value );
+					if ( val ) {
+						elem.value = val;
+					}
+					return value;
+				}
+			}
+		}
+	},
+
+	removeAttr: function( elem, value ) {
+		var name,
+			i = 0,
+
+			// Attribute names can contain non-HTML whitespace characters
+			// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
+			attrNames = value && value.match( rnothtmlwhite );
+
+		if ( attrNames && elem.nodeType === 1 ) {
+			while ( ( name = attrNames[ i++ ] ) ) {
+				elem.removeAttribute( name );
+			}
+		}
+	}
+} );
+
+// Hooks for boolean attributes
+boolHook = {
+	set: function( elem, value, name ) {
+		if ( value === false ) {
+
+			// Remove boolean attributes when set to false
+			jQuery.removeAttr( elem, name );
+		} else {
+			elem.setAttribute( name, name );
+		}
+		return name;
+	}
+};
+
+jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) {
+	var getter = attrHandle[ name ] || jQuery.find.attr;
+
+	attrHandle[ name ] = function( elem, name, isXML ) {
+		var ret, handle,
+			lowercaseName = name.toLowerCase();
+
+		if ( !isXML ) {
+
+			// Avoid an infinite loop by temporarily removing this function from the getter
+			handle = attrHandle[ lowercaseName ];
+			attrHandle[ lowercaseName ] = ret;
+			ret = getter( elem, name, isXML ) != null ?
+				lowercaseName :
+				null;
+			attrHandle[ lowercaseName ] = handle;
+		}
+		return ret;
+	};
+} );
+
+
+
+
+var rfocusable = /^(?:input|select|textarea|button)$/i,
+	rclickable = /^(?:a|area)$/i;
+
+jQuery.fn.extend( {
+	prop: function( name, value ) {
+		return access( this, jQuery.prop, name, value, arguments.length > 1 );
+	},
+
+	removeProp: function( name ) {
+		return this.each( function() {
+			delete this[ jQuery.propFix[ name ] || name ];
+		} );
+	}
+} );
+
+jQuery.extend( {
+	prop: function( elem, name, value ) {
+		var ret, hooks,
+			nType = elem.nodeType;
+
+		// Don't get/set properties on text, comment and attribute nodes
+		if ( nType === 3 || nType === 8 || nType === 2 ) {
+			return;
+		}
+
+		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
+
+			// Fix name and attach hooks
+			name = jQuery.propFix[ name ] || name;
+			hooks = jQuery.propHooks[ name ];
+		}
+
+		if ( value !== undefined ) {
+			if ( hooks && "set" in hooks &&
+				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
+				return ret;
+			}
+
+			return ( elem[ name ] = value );
+		}
+
+		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
+			return ret;
+		}
+
+		return elem[ name ];
+	},
+
+	propHooks: {
+		tabIndex: {
+			get: function( elem ) {
+
+				// Support: IE <=9 - 11 only
+				// elem.tabIndex doesn't always return the
+				// correct value when it hasn't been explicitly set
+				// Use proper attribute retrieval (trac-12072)
+				var tabindex = jQuery.find.attr( elem, "tabindex" );
+
+				if ( tabindex ) {
+					return parseInt( tabindex, 10 );
+				}
+
+				if (
+					rfocusable.test( elem.nodeName ) ||
+					rclickable.test( elem.nodeName ) &&
+					elem.href
+				) {
+					return 0;
+				}
+
+				return -1;
+			}
+		}
+	},
+
+	propFix: {
+		"for": "htmlFor",
+		"class": "className"
+	}
+} );
+
+// Support: IE <=11 only
+// Accessing the selectedIndex property
+// forces the browser to respect setting selected
+// on the option
+// The getter ensures a default option is selected
+// when in an optgroup
+// eslint rule "no-unused-expressions" is disabled for this code
+// since it considers such accessions noop
+if ( !support.optSelected ) {
+	jQuery.propHooks.selected = {
+		get: function( elem ) {
+
+			/* eslint no-unused-expressions: "off" */
+
+			var parent = elem.parentNode;
+			if ( parent && parent.parentNode ) {
+				parent.parentNode.selectedIndex;
+			}
+			return null;
+		},
+		set: function( elem ) {
+
+			/* eslint no-unused-expressions: "off" */
+
+			var parent = elem.parentNode;
+			if ( parent ) {
+				parent.selectedIndex;
+
+				if ( parent.parentNode ) {
+					parent.parentNode.selectedIndex;
+				}
+			}
+		}
+	};
+}
+
+jQuery.each( [
+	"tabIndex",
+	"readOnly",
+	"maxLength",
+	"cellSpacing",
+	"cellPadding",
+	"rowSpan",
+	"colSpan",
+	"useMap",
+	"frameBorder",
+	"contentEditable"
+], function() {
+	jQuery.propFix[ this.toLowerCase() ] = this;
+} );
+
+
+
+
+	// Strip and collapse whitespace according to HTML spec
+	// https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
+	function stripAndCollapse( value ) {
+		var tokens = value.match( rnothtmlwhite ) || [];
+		return tokens.join( " " );
+	}
+
+
+function getClass( elem ) {
+	return elem.getAttribute && elem.getAttribute( "class" ) || "";
+}
+
+function classesToArray( value ) {
+	if ( Array.isArray( value ) ) {
+		return value;
+	}
+	if ( typeof value === "string" ) {
+		return value.match( rnothtmlwhite ) || [];
+	}
+	return [];
+}
+
+jQuery.fn.extend( {
+	addClass: function( value ) {
+		var classNames, cur, curValue, className, i, finalValue;
+
+		if ( isFunction( value ) ) {
+			return this.each( function( j ) {
+				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
+			} );
+		}
+
+		classNames = classesToArray( value );
+
+		if ( classNames.length ) {
+			return this.each( function() {
+				curValue = getClass( this );
+				cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
+
+				if ( cur ) {
+					for ( i = 0; i < classNames.length; i++ ) {
+						className = classNames[ i ];
+						if ( cur.indexOf( " " + className + " " ) < 0 ) {
+							cur += className + " ";
+						}
+					}
+
+					// Only assign if different to avoid unneeded rendering.
+					finalValue = stripAndCollapse( cur );
+					if ( curValue !== finalValue ) {
+						this.setAttribute( "class", finalValue );
+					}
+				}
+			} );
+		}
+
+		return this;
+	},
+
+	removeClass: function( value ) {
+		var classNames, cur, curValue, className, i, finalValue;
+
+		if ( isFunction( value ) ) {
+			return this.each( function( j ) {
+				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
+			} );
+		}
+
+		if ( !arguments.length ) {
+			return this.attr( "class", "" );
+		}
+
+		classNames = classesToArray( value );
+
+		if ( classNames.length ) {
+			return this.each( function() {
+				curValue = getClass( this );
+
+				// This expression is here for better compressibility (see addClass)
+				cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
+
+				if ( cur ) {
+					for ( i = 0; i < classNames.length; i++ ) {
+						className = classNames[ i ];
+
+						// Remove *all* instances
+						while ( cur.indexOf( " " + className + " " ) > -1 ) {
+							cur = cur.replace( " " + className + " ", " " );
+						}
+					}
+
+					// Only assign if different to avoid unneeded rendering.
+					finalValue = stripAndCollapse( cur );
+					if ( curValue !== finalValue ) {
+						this.setAttribute( "class", finalValue );
+					}
+				}
+			} );
+		}
+
+		return this;
+	},
+
+	toggleClass: function( value, stateVal ) {
+		var classNames, className, i, self,
+			type = typeof value,
+			isValidValue = type === "string" || Array.isArray( value );
+
+		if ( isFunction( value ) ) {
+			return this.each( function( i ) {
+				jQuery( this ).toggleClass(
+					value.call( this, i, getClass( this ), stateVal ),
+					stateVal
+				);
+			} );
+		}
+
+		if ( typeof stateVal === "boolean" && isValidValue ) {
+			return stateVal ? this.addClass( value ) : this.removeClass( value );
+		}
+
+		classNames = classesToArray( value );
+
+		return this.each( function() {
+			if ( isValidValue ) {
+
+				// Toggle individual class names
+				self = jQuery( this );
+
+				for ( i = 0; i < classNames.length; i++ ) {
+					className = classNames[ i ];
+
+					// Check each className given, space separated list
+					if ( self.hasClass( className ) ) {
+						self.removeClass( className );
+					} else {
+						self.addClass( className );
+					}
+				}
+
+			// Toggle whole class name
+			} else if ( value === undefined || type === "boolean" ) {
+				className = getClass( this );
+				if ( className ) {
+
+					// Store className if set
+					dataPriv.set( this, "__className__", className );
+				}
+
+				// If the element has a class name or if we're passed `false`,
+				// then remove the whole classname (if there was one, the above saved it).
+				// Otherwise bring back whatever was previously saved (if anything),
+				// falling back to the empty string if nothing was stored.
+				if ( this.setAttribute ) {
+					this.setAttribute( "class",
+						className || value === false ?
+							"" :
+							dataPriv.get( this, "__className__" ) || ""
+					);
+				}
+			}
+		} );
+	},
+
+	hasClass: function( selector ) {
+		var className, elem,
+			i = 0;
+
+		className = " " + selector + " ";
+		while ( ( elem = this[ i++ ] ) ) {
+			if ( elem.nodeType === 1 &&
+				( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+} );
+
+
+
+
+var rreturn = /\r/g;
+
+jQuery.fn.extend( {
+	val: function( value ) {
+		var hooks, ret, valueIsFunction,
+			elem = this[ 0 ];
+
+		if ( !arguments.length ) {
+			if ( elem ) {
+				hooks = jQuery.valHooks[ elem.type ] ||
+					jQuery.valHooks[ elem.nodeName.toLowerCase() ];
+
+				if ( hooks &&
+					"get" in hooks &&
+					( ret = hooks.get( elem, "value" ) ) !== undefined
+				) {
+					return ret;
+				}
+
+				ret = elem.value;
+
+				// Handle most common string cases
+				if ( typeof ret === "string" ) {
+					return ret.replace( rreturn, "" );
+				}
+
+				// Handle cases where value is null/undef or number
+				return ret == null ? "" : ret;
+			}
+
+			return;
+		}
+
+		valueIsFunction = isFunction( value );
+
+		return this.each( function( i ) {
+			var val;
+
+			if ( this.nodeType !== 1 ) {
+				return;
+			}
+
+			if ( valueIsFunction ) {
+				val = value.call( this, i, jQuery( this ).val() );
+			} else {
+				val = value;
+			}
+
+			// Treat null/undefined as ""; convert numbers to string
+			if ( val == null ) {
+				val = "";
+
+			} else if ( typeof val === "number" ) {
+				val += "";
+
+			} else if ( Array.isArray( val ) ) {
+				val = jQuery.map( val, function( value ) {
+					return value == null ? "" : value + "";
+				} );
+			}
+
+			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
+
+			// If set returns undefined, fall back to normal setting
+			if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
+				this.value = val;
+			}
+		} );
+	}
+} );
+
+jQuery.extend( {
+	valHooks: {
+		option: {
+			get: function( elem ) {
+
+				var val = jQuery.find.attr( elem, "value" );
+				return val != null ?
+					val :
+
+					// Support: IE <=10 - 11 only
+					// option.text throws exceptions (trac-14686, trac-14858)
+					// Strip and collapse whitespace
+					// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
+					stripAndCollapse( jQuery.text( elem ) );
+			}
+		},
+		select: {
+			get: function( elem ) {
+				var value, option, i,
+					options = elem.options,
+					index = elem.selectedIndex,
+					one = elem.type === "select-one",
+					values = one ? null : [],
+					max = one ? index + 1 : options.length;
+
+				if ( index < 0 ) {
+					i = max;
+
+				} else {
+					i = one ? index : 0;
+				}
+
+				// Loop through all the selected options
+				for ( ; i < max; i++ ) {
+					option = options[ i ];
+
+					// Support: IE <=9 only
+					// IE8-9 doesn't update selected after form reset (trac-2551)
+					if ( ( option.selected || i === index ) &&
+
+							// Don't return options that are disabled or in a disabled optgroup
+							!option.disabled &&
+							( !option.parentNode.disabled ||
+								!nodeName( option.parentNode, "optgroup" ) ) ) {
+
+						// Get the specific value for the option
+						value = jQuery( option ).val();
+
+						// We don't need an array for one selects
+						if ( one ) {
+							return value;
+						}
+
+						// Multi-Selects return an array
+						values.push( value );
+					}
+				}
+
+				return values;
+			},
+
+			set: function( elem, value ) {
+				var optionSet, option,
+					options = elem.options,
+					values = jQuery.makeArray( value ),
+					i = options.length;
+
+				while ( i-- ) {
+					option = options[ i ];
+
+					/* eslint-disable no-cond-assign */
+
+					if ( option.selected =
+						jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
+					) {
+						optionSet = true;
+					}
+
+					/* eslint-enable no-cond-assign */
+				}
+
+				// Force browsers to behave consistently when non-matching value is set
+				if ( !optionSet ) {
+					elem.selectedIndex = -1;
+				}
+				return values;
+			}
+		}
+	}
+} );
+
+// Radios and checkboxes getter/setter
+jQuery.each( [ "radio", "checkbox" ], function() {
+	jQuery.valHooks[ this ] = {
+		set: function( elem, value ) {
+			if ( Array.isArray( value ) ) {
+				return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
+			}
+		}
+	};
+	if ( !support.checkOn ) {
+		jQuery.valHooks[ this ].get = function( elem ) {
+			return elem.getAttribute( "value" ) === null ? "on" : elem.value;
+		};
+	}
+} );
+
+
+
+
+// Return jQuery for attributes-only inclusion
+var location = window.location;
+
+var nonce = { guid: Date.now() };
+
+var rquery = ( /\?/ );
+
+
+
+// Cross-browser xml parsing
+jQuery.parseXML = function( data ) {
+	var xml, parserErrorElem;
+	if ( !data || typeof data !== "string" ) {
+		return null;
+	}
+
+	// Support: IE 9 - 11 only
+	// IE throws on parseFromString with invalid input.
+	try {
+		xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
+	} catch ( e ) {}
+
+	parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ];
+	if ( !xml || parserErrorElem ) {
+		jQuery.error( "Invalid XML: " + (
+			parserErrorElem ?
+				jQuery.map( parserErrorElem.childNodes, function( el ) {
+					return el.textContent;
+				} ).join( "\n" ) :
+				data
+		) );
+	}
+	return xml;
+};
+
+
+var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
+	stopPropagationCallback = function( e ) {
+		e.stopPropagation();
+	};
+
+jQuery.extend( jQuery.event, {
+
+	trigger: function( event, data, elem, onlyHandlers ) {
+
+		var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
+			eventPath = [ elem || document ],
+			type = hasOwn.call( event, "type" ) ? event.type : event,
+			namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
+
+		cur = lastElement = tmp = elem = elem || document;
+
+		// Don't do events on text and comment nodes
+		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
+			return;
+		}
+
+		// focus/blur morphs to focusin/out; ensure we're not firing them right now
+		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
+			return;
+		}
+
+		if ( type.indexOf( "." ) > -1 ) {
+
+			// Namespaced trigger; create a regexp to match event type in handle()
+			namespaces = type.split( "." );
+			type = namespaces.shift();
+			namespaces.sort();
+		}
+		ontype = type.indexOf( ":" ) < 0 && "on" + type;
+
+		// Caller can pass in a jQuery.Event object, Object, or just an event type string
+		event = event[ jQuery.expando ] ?
+			event :
+			new jQuery.Event( type, typeof event === "object" && event );
+
+		// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
+		event.isTrigger = onlyHandlers ? 2 : 3;
+		event.namespace = namespaces.join( "." );
+		event.rnamespace = event.namespace ?
+			new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
+			null;
+
+		// Clean up the event in case it is being reused
+		event.result = undefined;
+		if ( !event.target ) {
+			event.target = elem;
+		}
+
+		// Clone any incoming data and prepend the event, creating the handler arg list
+		data = data == null ?
+			[ event ] :
+			jQuery.makeArray( data, [ event ] );
+
+		// Allow special events to draw outside the lines
+		special = jQuery.event.special[ type ] || {};
+		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
+			return;
+		}
+
+		// Determine event propagation path in advance, per W3C events spec (trac-9951)
+		// Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724)
+		if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {
+
+			bubbleType = special.delegateType || type;
+			if ( !rfocusMorph.test( bubbleType + type ) ) {
+				cur = cur.parentNode;
+			}
+			for ( ; cur; cur = cur.parentNode ) {
+				eventPath.push( cur );
+				tmp = cur;
+			}
+
+			// Only add window if we got to document (e.g., not plain obj or detached DOM)
+			if ( tmp === ( elem.ownerDocument || document ) ) {
+				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
+			}
+		}
+
+		// Fire handlers on the event path
+		i = 0;
+		while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
+			lastElement = cur;
+			event.type = i > 1 ?
+				bubbleType :
+				special.bindType || type;
+
+			// jQuery handler
+			handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] &&
+				dataPriv.get( cur, "handle" );
+			if ( handle ) {
+				handle.apply( cur, data );
+			}
+
+			// Native handler
+			handle = ontype && cur[ ontype ];
+			if ( handle && handle.apply && acceptData( cur ) ) {
+				event.result = handle.apply( cur, data );
+				if ( event.result === false ) {
+					event.preventDefault();
+				}
+			}
+		}
+		event.type = type;
+
+		// If nobody prevented the default action, do it now
+		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
+
+			if ( ( !special._default ||
+				special._default.apply( eventPath.pop(), data ) === false ) &&
+				acceptData( elem ) ) {
+
+				// Call a native DOM method on the target with the same name as the event.
+				// Don't do default actions on window, that's where global variables be (trac-6170)
+				if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {
+
+					// Don't re-trigger an onFOO event when we call its FOO() method
+					tmp = elem[ ontype ];
+
+					if ( tmp ) {
+						elem[ ontype ] = null;
+					}
+
+					// Prevent re-triggering of the same event, since we already bubbled it above
+					jQuery.event.triggered = type;
+
+					if ( event.isPropagationStopped() ) {
+						lastElement.addEventListener( type, stopPropagationCallback );
+					}
+
+					elem[ type ]();
+
+					if ( event.isPropagationStopped() ) {
+						lastElement.removeEventListener( type, stopPropagationCallback );
+					}
+
+					jQuery.event.triggered = undefined;
+
+					if ( tmp ) {
+						elem[ ontype ] = tmp;
+					}
+				}
+			}
+		}
+
+		return event.result;
+	},
+
+	// Piggyback on a donor event to simulate a different one
+	// Used only for `focus(in | out)` events
+	simulate: function( type, elem, event ) {
+		var e = jQuery.extend(
+			new jQuery.Event(),
+			event,
+			{
+				type: type,
+				isSimulated: true
+			}
+		);
+
+		jQuery.event.trigger( e, null, elem );
+	}
+
+} );
+
+jQuery.fn.extend( {
+
+	trigger: function( type, data ) {
+		return this.each( function() {
+			jQuery.event.trigger( type, data, this );
+		} );
+	},
+	triggerHandler: function( type, data ) {
+		var elem = this[ 0 ];
+		if ( elem ) {
+			return jQuery.event.trigger( type, data, elem, true );
+		}
+	}
+} );
+
+
+var
+	rbracket = /\[\]$/,
+	rCRLF = /\r?\n/g,
+	rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
+	rsubmittable = /^(?:input|select|textarea|keygen)/i;
+
+function buildParams( prefix, obj, traditional, add ) {
+	var name;
+
+	if ( Array.isArray( obj ) ) {
+
+		// Serialize array item.
+		jQuery.each( obj, function( i, v ) {
+			if ( traditional || rbracket.test( prefix ) ) {
+
+				// Treat each array item as a scalar.
+				add( prefix, v );
+
+			} else {
+
+				// Item is non-scalar (array or object), encode its numeric index.
+				buildParams(
+					prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
+					v,
+					traditional,
+					add
+				);
+			}
+		} );
+
+	} else if ( !traditional && toType( obj ) === "object" ) {
+
+		// Serialize object item.
+		for ( name in obj ) {
+			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
+		}
+
+	} else {
+
+		// Serialize scalar item.
+		add( prefix, obj );
+	}
+}
+
+// Serialize an array of form elements or a set of
+// key/values into a query string
+jQuery.param = function( a, traditional ) {
+	var prefix,
+		s = [],
+		add = function( key, valueOrFunction ) {
+
+			// If value is a function, invoke it and use its return value
+			var value = isFunction( valueOrFunction ) ?
+				valueOrFunction() :
+				valueOrFunction;
+
+			s[ s.length ] = encodeURIComponent( key ) + "=" +
+				encodeURIComponent( value == null ? "" : value );
+		};
+
+	if ( a == null ) {
+		return "";
+	}
+
+	// If an array was passed in, assume that it is an array of form elements.
+	if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
+
+		// Serialize the form elements
+		jQuery.each( a, function() {
+			add( this.name, this.value );
+		} );
+
+	} else {
+
+		// If traditional, encode the "old" way (the way 1.3.2 or older
+		// did it), otherwise encode params recursively.
+		for ( prefix in a ) {
+			buildParams( prefix, a[ prefix ], traditional, add );
+		}
+	}
+
+	// Return the resulting serialization
+	return s.join( "&" );
+};
+
+jQuery.fn.extend( {
+	serialize: function() {
+		return jQuery.param( this.serializeArray() );
+	},
+	serializeArray: function() {
+		return this.map( function() {
+
+			// Can add propHook for "elements" to filter or add form elements
+			var elements = jQuery.prop( this, "elements" );
+			return elements ? jQuery.makeArray( elements ) : this;
+		} ).filter( function() {
+			var type = this.type;
+
+			// Use .is( ":disabled" ) so that fieldset[disabled] works
+			return this.name && !jQuery( this ).is( ":disabled" ) &&
+				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
+				( this.checked || !rcheckableType.test( type ) );
+		} ).map( function( _i, elem ) {
+			var val = jQuery( this ).val();
+
+			if ( val == null ) {
+				return null;
+			}
+
+			if ( Array.isArray( val ) ) {
+				return jQuery.map( val, function( val ) {
+					return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+				} );
+			}
+
+			return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
+		} ).get();
+	}
+} );
+
+
+var
+	r20 = /%20/g,
+	rhash = /#.*$/,
+	rantiCache = /([?&])_=[^&]*/,
+	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
+
+	// trac-7653, trac-8125, trac-8152: local protocol detection
+	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
+	rnoContent = /^(?:GET|HEAD)$/,
+	rprotocol = /^\/\//,
+
+	/* Prefilters
+	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
+	 * 2) These are called:
+	 *    - BEFORE asking for a transport
+	 *    - AFTER param serialization (s.data is a string if s.processData is true)
+	 * 3) key is the dataType
+	 * 4) the catchall symbol "*" can be used
+	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
+	 */
+	prefilters = {},
+
+	/* Transports bindings
+	 * 1) key is the dataType
+	 * 2) the catchall symbol "*" can be used
+	 * 3) selection will start with transport dataType and THEN go to "*" if needed
+	 */
+	transports = {},
+
+	// Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression
+	allTypes = "*/".concat( "*" ),
+
+	// Anchor tag for parsing the document origin
+	originAnchor = document.createElement( "a" );
+
+originAnchor.href = location.href;
+
+// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
+function addToPrefiltersOrTransports( structure ) {
+
+	// dataTypeExpression is optional and defaults to "*"
+	return function( dataTypeExpression, func ) {
+
+		if ( typeof dataTypeExpression !== "string" ) {
+			func = dataTypeExpression;
+			dataTypeExpression = "*";
+		}
+
+		var dataType,
+			i = 0,
+			dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
+
+		if ( isFunction( func ) ) {
+
+			// For each dataType in the dataTypeExpression
+			while ( ( dataType = dataTypes[ i++ ] ) ) {
+
+				// Prepend if requested
+				if ( dataType[ 0 ] === "+" ) {
+					dataType = dataType.slice( 1 ) || "*";
+					( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
+
+				// Otherwise append
+				} else {
+					( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
+				}
+			}
+		}
+	};
+}
+
+// Base inspection function for prefilters and transports
+function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
+
+	var inspected = {},
+		seekingTransport = ( structure === transports );
+
+	function inspect( dataType ) {
+		var selected;
+		inspected[ dataType ] = true;
+		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
+			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
+			if ( typeof dataTypeOrTransport === "string" &&
+				!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
+
+				options.dataTypes.unshift( dataTypeOrTransport );
+				inspect( dataTypeOrTransport );
+				return false;
+			} else if ( seekingTransport ) {
+				return !( selected = dataTypeOrTransport );
+			}
+		} );
+		return selected;
+	}
+
+	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
+}
+
+// A special extend for ajax options
+// that takes "flat" options (not to be deep extended)
+// Fixes trac-9887
+function ajaxExtend( target, src ) {
+	var key, deep,
+		flatOptions = jQuery.ajaxSettings.flatOptions || {};
+
+	for ( key in src ) {
+		if ( src[ key ] !== undefined ) {
+			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
+		}
+	}
+	if ( deep ) {
+		jQuery.extend( true, target, deep );
+	}
+
+	return target;
+}
+
+/* Handles responses to an ajax request:
+ * - finds the right dataType (mediates between content-type and expected dataType)
+ * - returns the corresponding response
+ */
+function ajaxHandleResponses( s, jqXHR, responses ) {
+
+	var ct, type, finalDataType, firstDataType,
+		contents = s.contents,
+		dataTypes = s.dataTypes;
+
+	// Remove auto dataType and get content-type in the process
+	while ( dataTypes[ 0 ] === "*" ) {
+		dataTypes.shift();
+		if ( ct === undefined ) {
+			ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
+		}
+	}
+
+	// Check if we're dealing with a known content-type
+	if ( ct ) {
+		for ( type in contents ) {
+			if ( contents[ type ] && contents[ type ].test( ct ) ) {
+				dataTypes.unshift( type );
+				break;
+			}
+		}
+	}
+
+	// Check to see if we have a response for the expected dataType
+	if ( dataTypes[ 0 ] in responses ) {
+		finalDataType = dataTypes[ 0 ];
+	} else {
+
+		// Try convertible dataTypes
+		for ( type in responses ) {
+			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
+				finalDataType = type;
+				break;
+			}
+			if ( !firstDataType ) {
+				firstDataType = type;
+			}
+		}
+
+		// Or just use first one
+		finalDataType = finalDataType || firstDataType;
+	}
+
+	// If we found a dataType
+	// We add the dataType to the list if needed
+	// and return the corresponding response
+	if ( finalDataType ) {
+		if ( finalDataType !== dataTypes[ 0 ] ) {
+			dataTypes.unshift( finalDataType );
+		}
+		return responses[ finalDataType ];
+	}
+}
+
+/* Chain conversions given the request and the original response
+ * Also sets the responseXXX fields on the jqXHR instance
+ */
+function ajaxConvert( s, response, jqXHR, isSuccess ) {
+	var conv2, current, conv, tmp, prev,
+		converters = {},
+
+		// Work with a copy of dataTypes in case we need to modify it for conversion
+		dataTypes = s.dataTypes.slice();
+
+	// Create converters map with lowercased keys
+	if ( dataTypes[ 1 ] ) {
+		for ( conv in s.converters ) {
+			converters[ conv.toLowerCase() ] = s.converters[ conv ];
+		}
+	}
+
+	current = dataTypes.shift();
+
+	// Convert to each sequential dataType
+	while ( current ) {
+
+		if ( s.responseFields[ current ] ) {
+			jqXHR[ s.responseFields[ current ] ] = response;
+		}
+
+		// Apply the dataFilter if provided
+		if ( !prev && isSuccess && s.dataFilter ) {
+			response = s.dataFilter( response, s.dataType );
+		}
+
+		prev = current;
+		current = dataTypes.shift();
+
+		if ( current ) {
+
+			// There's only work to do if current dataType is non-auto
+			if ( current === "*" ) {
+
+				current = prev;
+
+			// Convert response if prev dataType is non-auto and differs from current
+			} else if ( prev !== "*" && prev !== current ) {
+
+				// Seek a direct converter
+				conv = converters[ prev + " " + current ] || converters[ "* " + current ];
+
+				// If none found, seek a pair
+				if ( !conv ) {
+					for ( conv2 in converters ) {
+
+						// If conv2 outputs current
+						tmp = conv2.split( " " );
+						if ( tmp[ 1 ] === current ) {
+
+							// If prev can be converted to accepted input
+							conv = converters[ prev + " " + tmp[ 0 ] ] ||
+								converters[ "* " + tmp[ 0 ] ];
+							if ( conv ) {
+
+								// Condense equivalence converters
+								if ( conv === true ) {
+									conv = converters[ conv2 ];
+
+								// Otherwise, insert the intermediate dataType
+								} else if ( converters[ conv2 ] !== true ) {
+									current = tmp[ 0 ];
+									dataTypes.unshift( tmp[ 1 ] );
+								}
+								break;
+							}
+						}
+					}
+				}
+
+				// Apply converter (if not an equivalence)
+				if ( conv !== true ) {
+
+					// Unless errors are allowed to bubble, catch and return them
+					if ( conv && s.throws ) {
+						response = conv( response );
+					} else {
+						try {
+							response = conv( response );
+						} catch ( e ) {
+							return {
+								state: "parsererror",
+								error: conv ? e : "No conversion from " + prev + " to " + current
+							};
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return { state: "success", data: response };
+}
+
+jQuery.extend( {
+
+	// Counter for holding the number of active queries
+	active: 0,
+
+	// Last-Modified header cache for next request
+	lastModified: {},
+	etag: {},
+
+	ajaxSettings: {
+		url: location.href,
+		type: "GET",
+		isLocal: rlocalProtocol.test( location.protocol ),
+		global: true,
+		processData: true,
+		async: true,
+		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
+
+		/*
+		timeout: 0,
+		data: null,
+		dataType: null,
+		username: null,
+		password: null,
+		cache: null,
+		throws: false,
+		traditional: false,
+		headers: {},
+		*/
+
+		accepts: {
+			"*": allTypes,
+			text: "text/plain",
+			html: "text/html",
+			xml: "application/xml, text/xml",
+			json: "application/json, text/javascript"
+		},
+
+		contents: {
+			xml: /\bxml\b/,
+			html: /\bhtml/,
+			json: /\bjson\b/
+		},
+
+		responseFields: {
+			xml: "responseXML",
+			text: "responseText",
+			json: "responseJSON"
+		},
+
+		// Data converters
+		// Keys separate source (or catchall "*") and destination types with a single space
+		converters: {
+
+			// Convert anything to text
+			"* text": String,
+
+			// Text to html (true = no transformation)
+			"text html": true,
+
+			// Evaluate text as a json expression
+			"text json": JSON.parse,
+
+			// Parse text as xml
+			"text xml": jQuery.parseXML
+		},
+
+		// For options that shouldn't be deep extended:
+		// you can add your own custom options here if
+		// and when you create one that shouldn't be
+		// deep extended (see ajaxExtend)
+		flatOptions: {
+			url: true,
+			context: true
+		}
+	},
+
+	// Creates a full fledged settings object into target
+	// with both ajaxSettings and settings fields.
+	// If target is omitted, writes into ajaxSettings.
+	ajaxSetup: function( target, settings ) {
+		return settings ?
+
+			// Building a settings object
+			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
+
+			// Extending ajaxSettings
+			ajaxExtend( jQuery.ajaxSettings, target );
+	},
+
+	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
+	ajaxTransport: addToPrefiltersOrTransports( transports ),
+
+	// Main method
+	ajax: function( url, options ) {
+
+		// If url is an object, simulate pre-1.5 signature
+		if ( typeof url === "object" ) {
+			options = url;
+			url = undefined;
+		}
+
+		// Force options to be an object
+		options = options || {};
+
+		var transport,
+
+			// URL without anti-cache param
+			cacheURL,
+
+			// Response headers
+			responseHeadersString,
+			responseHeaders,
+
+			// timeout handle
+			timeoutTimer,
+
+			// Url cleanup var
+			urlAnchor,
+
+			// Request state (becomes false upon send and true upon completion)
+			completed,
+
+			// To know if global events are to be dispatched
+			fireGlobals,
+
+			// Loop variable
+			i,
+
+			// uncached part of the url
+			uncached,
+
+			// Create the final options object
+			s = jQuery.ajaxSetup( {}, options ),
+
+			// Callbacks context
+			callbackContext = s.context || s,
+
+			// Context for global events is callbackContext if it is a DOM node or jQuery collection
+			globalEventContext = s.context &&
+				( callbackContext.nodeType || callbackContext.jquery ) ?
+				jQuery( callbackContext ) :
+				jQuery.event,
+
+			// Deferreds
+			deferred = jQuery.Deferred(),
+			completeDeferred = jQuery.Callbacks( "once memory" ),
+
+			// Status-dependent callbacks
+			statusCode = s.statusCode || {},
+
+			// Headers (they are sent all at once)
+			requestHeaders = {},
+			requestHeadersNames = {},
+
+			// Default abort message
+			strAbort = "canceled",
+
+			// Fake xhr
+			jqXHR = {
+				readyState: 0,
+
+				// Builds headers hashtable if needed
+				getResponseHeader: function( key ) {
+					var match;
+					if ( completed ) {
+						if ( !responseHeaders ) {
+							responseHeaders = {};
+							while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
+								responseHeaders[ match[ 1 ].toLowerCase() + " " ] =
+									( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )
+										.concat( match[ 2 ] );
+							}
+						}
+						match = responseHeaders[ key.toLowerCase() + " " ];
+					}
+					return match == null ? null : match.join( ", " );
+				},
+
+				// Raw string
+				getAllResponseHeaders: function() {
+					return completed ? responseHeadersString : null;
+				},
+
+				// Caches the header
+				setRequestHeader: function( name, value ) {
+					if ( completed == null ) {
+						name = requestHeadersNames[ name.toLowerCase() ] =
+							requestHeadersNames[ name.toLowerCase() ] || name;
+						requestHeaders[ name ] = value;
+					}
+					return this;
+				},
+
+				// Overrides response content-type header
+				overrideMimeType: function( type ) {
+					if ( completed == null ) {
+						s.mimeType = type;
+					}
+					return this;
+				},
+
+				// Status-dependent callbacks
+				statusCode: function( map ) {
+					var code;
+					if ( map ) {
+						if ( completed ) {
+
+							// Execute the appropriate callbacks
+							jqXHR.always( map[ jqXHR.status ] );
+						} else {
+
+							// Lazy-add the new callbacks in a way that preserves old ones
+							for ( code in map ) {
+								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
+							}
+						}
+					}
+					return this;
+				},
+
+				// Cancel the request
+				abort: function( statusText ) {
+					var finalText = statusText || strAbort;
+					if ( transport ) {
+						transport.abort( finalText );
+					}
+					done( 0, finalText );
+					return this;
+				}
+			};
+
+		// Attach deferreds
+		deferred.promise( jqXHR );
+
+		// Add protocol if not provided (prefilters might expect it)
+		// Handle falsy url in the settings object (trac-10093: consistency with old signature)
+		// We also use the url parameter if available
+		s.url = ( ( url || s.url || location.href ) + "" )
+			.replace( rprotocol, location.protocol + "//" );
+
+		// Alias method option to type as per ticket trac-12004
+		s.type = options.method || options.type || s.method || s.type;
+
+		// Extract dataTypes list
+		s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
+
+		// A cross-domain request is in order when the origin doesn't match the current origin.
+		if ( s.crossDomain == null ) {
+			urlAnchor = document.createElement( "a" );
+
+			// Support: IE <=8 - 11, Edge 12 - 15
+			// IE throws exception on accessing the href property if url is malformed,
+			// e.g. http://example.com:80x/
+			try {
+				urlAnchor.href = s.url;
+
+				// Support: IE <=8 - 11 only
+				// Anchor's host property isn't correctly set when s.url is relative
+				urlAnchor.href = urlAnchor.href;
+				s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
+					urlAnchor.protocol + "//" + urlAnchor.host;
+			} catch ( e ) {
+
+				// If there is an error parsing the URL, assume it is crossDomain,
+				// it can be rejected by the transport if it is invalid
+				s.crossDomain = true;
+			}
+		}
+
+		// Convert data if not already a string
+		if ( s.data && s.processData && typeof s.data !== "string" ) {
+			s.data = jQuery.param( s.data, s.traditional );
+		}
+
+		// Apply prefilters
+		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
+
+		// If request was aborted inside a prefilter, stop there
+		if ( completed ) {
+			return jqXHR;
+		}
+
+		// We can fire global events as of now if asked to
+		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118)
+		fireGlobals = jQuery.event && s.global;
+
+		// Watch for a new set of requests
+		if ( fireGlobals && jQuery.active++ === 0 ) {
+			jQuery.event.trigger( "ajaxStart" );
+		}
+
+		// Uppercase the type
+		s.type = s.type.toUpperCase();
+
+		// Determine if request has content
+		s.hasContent = !rnoContent.test( s.type );
+
+		// Save the URL in case we're toying with the If-Modified-Since
+		// and/or If-None-Match header later on
+		// Remove hash to simplify url manipulation
+		cacheURL = s.url.replace( rhash, "" );
+
+		// More options handling for requests with no content
+		if ( !s.hasContent ) {
+
+			// Remember the hash so we can put it back
+			uncached = s.url.slice( cacheURL.length );
+
+			// If data is available and should be processed, append data to url
+			if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
+				cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
+
+				// trac-9682: remove data so that it's not used in an eventual retry
+				delete s.data;
+			}
+
+			// Add or update anti-cache param if needed
+			if ( s.cache === false ) {
+				cacheURL = cacheURL.replace( rantiCache, "$1" );
+				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) +
+					uncached;
+			}
+
+			// Put hash and anti-cache on the URL that will be requested (gh-1732)
+			s.url = cacheURL + uncached;
+
+		// Change '%20' to '+' if this is encoded form body content (gh-2658)
+		} else if ( s.data && s.processData &&
+			( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
+			s.data = s.data.replace( r20, "+" );
+		}
+
+		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+		if ( s.ifModified ) {
+			if ( jQuery.lastModified[ cacheURL ] ) {
+				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
+			}
+			if ( jQuery.etag[ cacheURL ] ) {
+				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
+			}
+		}
+
+		// Set the correct header, if data is being sent
+		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
+			jqXHR.setRequestHeader( "Content-Type", s.contentType );
+		}
+
+		// Set the Accepts header for the server, depending on the dataType
+		jqXHR.setRequestHeader(
+			"Accept",
+			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
+				s.accepts[ s.dataTypes[ 0 ] ] +
+					( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
+				s.accepts[ "*" ]
+		);
+
+		// Check for headers option
+		for ( i in s.headers ) {
+			jqXHR.setRequestHeader( i, s.headers[ i ] );
+		}
+
+		// Allow custom headers/mimetypes and early abort
+		if ( s.beforeSend &&
+			( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
+
+			// Abort if not done already and return
+			return jqXHR.abort();
+		}
+
+		// Aborting is no longer a cancellation
+		strAbort = "abort";
+
+		// Install callbacks on deferreds
+		completeDeferred.add( s.complete );
+		jqXHR.done( s.success );
+		jqXHR.fail( s.error );
+
+		// Get transport
+		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
+
+		// If no transport, we auto-abort
+		if ( !transport ) {
+			done( -1, "No Transport" );
+		} else {
+			jqXHR.readyState = 1;
+
+			// Send global event
+			if ( fireGlobals ) {
+				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
+			}
+
+			// If request was aborted inside ajaxSend, stop there
+			if ( completed ) {
+				return jqXHR;
+			}
+
+			// Timeout
+			if ( s.async && s.timeout > 0 ) {
+				timeoutTimer = window.setTimeout( function() {
+					jqXHR.abort( "timeout" );
+				}, s.timeout );
+			}
+
+			try {
+				completed = false;
+				transport.send( requestHeaders, done );
+			} catch ( e ) {
+
+				// Rethrow post-completion exceptions
+				if ( completed ) {
+					throw e;
+				}
+
+				// Propagate others as results
+				done( -1, e );
+			}
+		}
+
+		// Callback for when everything is done
+		function done( status, nativeStatusText, responses, headers ) {
+			var isSuccess, success, error, response, modified,
+				statusText = nativeStatusText;
+
+			// Ignore repeat invocations
+			if ( completed ) {
+				return;
+			}
+
+			completed = true;
+
+			// Clear timeout if it exists
+			if ( timeoutTimer ) {
+				window.clearTimeout( timeoutTimer );
+			}
+
+			// Dereference transport for early garbage collection
+			// (no matter how long the jqXHR object will be used)
+			transport = undefined;
+
+			// Cache response headers
+			responseHeadersString = headers || "";
+
+			// Set readyState
+			jqXHR.readyState = status > 0 ? 4 : 0;
+
+			// Determine if successful
+			isSuccess = status >= 200 && status < 300 || status === 304;
+
+			// Get response data
+			if ( responses ) {
+				response = ajaxHandleResponses( s, jqXHR, responses );
+			}
+
+			// Use a noop converter for missing script but not if jsonp
+			if ( !isSuccess &&
+				jQuery.inArray( "script", s.dataTypes ) > -1 &&
+				jQuery.inArray( "json", s.dataTypes ) < 0 ) {
+				s.converters[ "text script" ] = function() {};
+			}
+
+			// Convert no matter what (that way responseXXX fields are always set)
+			response = ajaxConvert( s, response, jqXHR, isSuccess );
+
+			// If successful, handle type chaining
+			if ( isSuccess ) {
+
+				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
+				if ( s.ifModified ) {
+					modified = jqXHR.getResponseHeader( "Last-Modified" );
+					if ( modified ) {
+						jQuery.lastModified[ cacheURL ] = modified;
+					}
+					modified = jqXHR.getResponseHeader( "etag" );
+					if ( modified ) {
+						jQuery.etag[ cacheURL ] = modified;
+					}
+				}
+
+				// if no content
+				if ( status === 204 || s.type === "HEAD" ) {
+					statusText = "nocontent";
+
+				// if not modified
+				} else if ( status === 304 ) {
+					statusText = "notmodified";
+
+				// If we have data, let's convert it
+				} else {
+					statusText = response.state;
+					success = response.data;
+					error = response.error;
+					isSuccess = !error;
+				}
+			} else {
+
+				// Extract error from statusText and normalize for non-aborts
+				error = statusText;
+				if ( status || !statusText ) {
+					statusText = "error";
+					if ( status < 0 ) {
+						status = 0;
+					}
+				}
+			}
+
+			// Set data for the fake xhr object
+			jqXHR.status = status;
+			jqXHR.statusText = ( nativeStatusText || statusText ) + "";
+
+			// Success/Error
+			if ( isSuccess ) {
+				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
+			} else {
+				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
+			}
+
+			// Status-dependent callbacks
+			jqXHR.statusCode( statusCode );
+			statusCode = undefined;
+
+			if ( fireGlobals ) {
+				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
+					[ jqXHR, s, isSuccess ? success : error ] );
+			}
+
+			// Complete
+			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
+
+			if ( fireGlobals ) {
+				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
+
+				// Handle the global AJAX counter
+				if ( !( --jQuery.active ) ) {
+					jQuery.event.trigger( "ajaxStop" );
+				}
+			}
+		}
+
+		return jqXHR;
+	},
+
+	getJSON: function( url, data, callback ) {
+		return jQuery.get( url, data, callback, "json" );
+	},
+
+	getScript: function( url, callback ) {
+		return jQuery.get( url, undefined, callback, "script" );
+	}
+} );
+
+jQuery.each( [ "get", "post" ], function( _i, method ) {
+	jQuery[ method ] = function( url, data, callback, type ) {
+
+		// Shift arguments if data argument was omitted
+		if ( isFunction( data ) ) {
+			type = type || callback;
+			callback = data;
+			data = undefined;
+		}
+
+		// The url can be an options object (which then must have .url)
+		return jQuery.ajax( jQuery.extend( {
+			url: url,
+			type: method,
+			dataType: type,
+			data: data,
+			success: callback
+		}, jQuery.isPlainObject( url ) && url ) );
+	};
+} );
+
+jQuery.ajaxPrefilter( function( s ) {
+	var i;
+	for ( i in s.headers ) {
+		if ( i.toLowerCase() === "content-type" ) {
+			s.contentType = s.headers[ i ] || "";
+		}
+	}
+} );
+
+
+jQuery._evalUrl = function( url, options, doc ) {
+	return jQuery.ajax( {
+		url: url,
+
+		// Make this explicit, since user can override this through ajaxSetup (trac-11264)
+		type: "GET",
+		dataType: "script",
+		cache: true,
+		async: false,
+		global: false,
+
+		// Only evaluate the response if it is successful (gh-4126)
+		// dataFilter is not invoked for failure responses, so using it instead
+		// of the default converter is kludgy but it works.
+		converters: {
+			"text script": function() {}
+		},
+		dataFilter: function( response ) {
+			jQuery.globalEval( response, options, doc );
+		}
+	} );
+};
+
+
+jQuery.fn.extend( {
+	wrapAll: function( html ) {
+		var wrap;
+
+		if ( this[ 0 ] ) {
+			if ( isFunction( html ) ) {
+				html = html.call( this[ 0 ] );
+			}
+
+			// The elements to wrap the target around
+			wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
+
+			if ( this[ 0 ].parentNode ) {
+				wrap.insertBefore( this[ 0 ] );
+			}
+
+			wrap.map( function() {
+				var elem = this;
+
+				while ( elem.firstElementChild ) {
+					elem = elem.firstElementChild;
+				}
+
+				return elem;
+			} ).append( this );
+		}
+
+		return this;
+	},
+
+	wrapInner: function( html ) {
+		if ( isFunction( html ) ) {
+			return this.each( function( i ) {
+				jQuery( this ).wrapInner( html.call( this, i ) );
+			} );
+		}
+
+		return this.each( function() {
+			var self = jQuery( this ),
+				contents = self.contents();
+
+			if ( contents.length ) {
+				contents.wrapAll( html );
+
+			} else {
+				self.append( html );
+			}
+		} );
+	},
+
+	wrap: function( html ) {
+		var htmlIsFunction = isFunction( html );
+
+		return this.each( function( i ) {
+			jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
+		} );
+	},
+
+	unwrap: function( selector ) {
+		this.parent( selector ).not( "body" ).each( function() {
+			jQuery( this ).replaceWith( this.childNodes );
+		} );
+		return this;
+	}
+} );
+
+
+jQuery.expr.pseudos.hidden = function( elem ) {
+	return !jQuery.expr.pseudos.visible( elem );
+};
+jQuery.expr.pseudos.visible = function( elem ) {
+	return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
+};
+
+
+
+
+jQuery.ajaxSettings.xhr = function() {
+	try {
+		return new window.XMLHttpRequest();
+	} catch ( e ) {}
+};
+
+var xhrSuccessStatus = {
+
+		// File protocol always yields status code 0, assume 200
+		0: 200,
+
+		// Support: IE <=9 only
+		// trac-1450: sometimes IE returns 1223 when it should be 204
+		1223: 204
+	},
+	xhrSupported = jQuery.ajaxSettings.xhr();
+
+support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
+support.ajax = xhrSupported = !!xhrSupported;
+
+jQuery.ajaxTransport( function( options ) {
+	var callback, errorCallback;
+
+	// Cross domain only allowed if supported through XMLHttpRequest
+	if ( support.cors || xhrSupported && !options.crossDomain ) {
+		return {
+			send: function( headers, complete ) {
+				var i,
+					xhr = options.xhr();
+
+				xhr.open(
+					options.type,
+					options.url,
+					options.async,
+					options.username,
+					options.password
+				);
+
+				// Apply custom fields if provided
+				if ( options.xhrFields ) {
+					for ( i in options.xhrFields ) {
+						xhr[ i ] = options.xhrFields[ i ];
+					}
+				}
+
+				// Override mime type if needed
+				if ( options.mimeType && xhr.overrideMimeType ) {
+					xhr.overrideMimeType( options.mimeType );
+				}
+
+				// X-Requested-With header
+				// For cross-domain requests, seeing as conditions for a preflight are
+				// akin to a jigsaw puzzle, we simply never set it to be sure.
+				// (it can always be set on a per-request basis or even using ajaxSetup)
+				// For same-domain requests, won't change header if already provided.
+				if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
+					headers[ "X-Requested-With" ] = "XMLHttpRequest";
+				}
+
+				// Set headers
+				for ( i in headers ) {
+					xhr.setRequestHeader( i, headers[ i ] );
+				}
+
+				// Callback
+				callback = function( type ) {
+					return function() {
+						if ( callback ) {
+							callback = errorCallback = xhr.onload =
+								xhr.onerror = xhr.onabort = xhr.ontimeout =
+									xhr.onreadystatechange = null;
+
+							if ( type === "abort" ) {
+								xhr.abort();
+							} else if ( type === "error" ) {
+
+								// Support: IE <=9 only
+								// On a manual native abort, IE9 throws
+								// errors on any property access that is not readyState
+								if ( typeof xhr.status !== "number" ) {
+									complete( 0, "error" );
+								} else {
+									complete(
+
+										// File: protocol always yields status 0; see trac-8605, trac-14207
+										xhr.status,
+										xhr.statusText
+									);
+								}
+							} else {
+								complete(
+									xhrSuccessStatus[ xhr.status ] || xhr.status,
+									xhr.statusText,
+
+									// Support: IE <=9 only
+									// IE9 has no XHR2 but throws on binary (trac-11426)
+									// For XHR2 non-text, let the caller handle it (gh-2498)
+									( xhr.responseType || "text" ) !== "text"  ||
+									typeof xhr.responseText !== "string" ?
+										{ binary: xhr.response } :
+										{ text: xhr.responseText },
+									xhr.getAllResponseHeaders()
+								);
+							}
+						}
+					};
+				};
+
+				// Listen to events
+				xhr.onload = callback();
+				errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );
+
+				// Support: IE 9 only
+				// Use onreadystatechange to replace onabort
+				// to handle uncaught aborts
+				if ( xhr.onabort !== undefined ) {
+					xhr.onabort = errorCallback;
+				} else {
+					xhr.onreadystatechange = function() {
+
+						// Check readyState before timeout as it changes
+						if ( xhr.readyState === 4 ) {
+
+							// Allow onerror to be called first,
+							// but that will not handle a native abort
+							// Also, save errorCallback to a variable
+							// as xhr.onerror cannot be accessed
+							window.setTimeout( function() {
+								if ( callback ) {
+									errorCallback();
+								}
+							} );
+						}
+					};
+				}
+
+				// Create the abort callback
+				callback = callback( "abort" );
+
+				try {
+
+					// Do send the request (this may raise an exception)
+					xhr.send( options.hasContent && options.data || null );
+				} catch ( e ) {
+
+					// trac-14683: Only rethrow if this hasn't been notified as an error yet
+					if ( callback ) {
+						throw e;
+					}
+				}
+			},
+
+			abort: function() {
+				if ( callback ) {
+					callback();
+				}
+			}
+		};
+	}
+} );
+
+
+
+
+// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
+jQuery.ajaxPrefilter( function( s ) {
+	if ( s.crossDomain ) {
+		s.contents.script = false;
+	}
+} );
+
+// Install script dataType
+jQuery.ajaxSetup( {
+	accepts: {
+		script: "text/javascript, application/javascript, " +
+			"application/ecmascript, application/x-ecmascript"
+	},
+	contents: {
+		script: /\b(?:java|ecma)script\b/
+	},
+	converters: {
+		"text script": function( text ) {
+			jQuery.globalEval( text );
+			return text;
+		}
+	}
+} );
+
+// Handle cache's special case and crossDomain
+jQuery.ajaxPrefilter( "script", function( s ) {
+	if ( s.cache === undefined ) {
+		s.cache = false;
+	}
+	if ( s.crossDomain ) {
+		s.type = "GET";
+	}
+} );
+
+// Bind script tag hack transport
+jQuery.ajaxTransport( "script", function( s ) {
+
+	// This transport only deals with cross domain or forced-by-attrs requests
+	if ( s.crossDomain || s.scriptAttrs ) {
+		var script, callback;
+		return {
+			send: function( _, complete ) {
+				script = jQuery( "<script>" )
+					.attr( s.scriptAttrs || {} )
+					.prop( { charset: s.scriptCharset, src: s.url } )
+					.on( "load error", callback = function( evt ) {
+						script.remove();
+						callback = null;
+						if ( evt ) {
+							complete( evt.type === "error" ? 404 : 200, evt.type );
+						}
+					} );
+
+				// Use native DOM manipulation to avoid our domManip AJAX trickery
+				document.head.appendChild( script[ 0 ] );
+			},
+			abort: function() {
+				if ( callback ) {
+					callback();
+				}
+			}
+		};
+	}
+} );
+
+
+
+
+var oldCallbacks = [],
+	rjsonp = /(=)\?(?=&|$)|\?\?/;
+
+// Default jsonp settings
+jQuery.ajaxSetup( {
+	jsonp: "callback",
+	jsonpCallback: function() {
+		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) );
+		this[ callback ] = true;
+		return callback;
+	}
+} );
+
+// Detect, normalize options and install callbacks for jsonp requests
+jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
+
+	var callbackName, overwritten, responseContainer,
+		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
+			"url" :
+			typeof s.data === "string" &&
+				( s.contentType || "" )
+					.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
+				rjsonp.test( s.data ) && "data"
+		);
+
+	// Handle iff the expected data type is "jsonp" or we have a parameter to set
+	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
+
+		// Get callback name, remembering preexisting value associated with it
+		callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?
+			s.jsonpCallback() :
+			s.jsonpCallback;
+
+		// Insert callback into url or form data
+		if ( jsonProp ) {
+			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
+		} else if ( s.jsonp !== false ) {
+			s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
+		}
+
+		// Use data converter to retrieve json after script execution
+		s.converters[ "script json" ] = function() {
+			if ( !responseContainer ) {
+				jQuery.error( callbackName + " was not called" );
+			}
+			return responseContainer[ 0 ];
+		};
+
+		// Force json dataType
+		s.dataTypes[ 0 ] = "json";
+
+		// Install callback
+		overwritten = window[ callbackName ];
+		window[ callbackName ] = function() {
+			responseContainer = arguments;
+		};
+
+		// Clean-up function (fires after converters)
+		jqXHR.always( function() {
+
+			// If previous value didn't exist - remove it
+			if ( overwritten === undefined ) {
+				jQuery( window ).removeProp( callbackName );
+
+			// Otherwise restore preexisting value
+			} else {
+				window[ callbackName ] = overwritten;
+			}
+
+			// Save back as free
+			if ( s[ callbackName ] ) {
+
+				// Make sure that re-using the options doesn't screw things around
+				s.jsonpCallback = originalSettings.jsonpCallback;
+
+				// Save the callback name for future use
+				oldCallbacks.push( callbackName );
+			}
+
+			// Call if it was a function and we have a response
+			if ( responseContainer && isFunction( overwritten ) ) {
+				overwritten( responseContainer[ 0 ] );
+			}
+
+			responseContainer = overwritten = undefined;
+		} );
+
+		// Delegate to script
+		return "script";
+	}
+} );
+
+
+
+
+// Support: Safari 8 only
+// In Safari 8 documents created via document.implementation.createHTMLDocument
+// collapse sibling forms: the second one becomes a child of the first one.
+// Because of that, this security measure has to be disabled in Safari 8.
+// https://bugs.webkit.org/show_bug.cgi?id=137337
+support.createHTMLDocument = ( function() {
+	var body = document.implementation.createHTMLDocument( "" ).body;
+	body.innerHTML = "<form></form><form></form>";
+	return body.childNodes.length === 2;
+} )();
+
+
+// Argument "data" should be string of html
+// context (optional): If specified, the fragment will be created in this context,
+// defaults to document
+// keepScripts (optional): If true, will include scripts passed in the html string
+jQuery.parseHTML = function( data, context, keepScripts ) {
+	if ( typeof data !== "string" ) {
+		return [];
+	}
+	if ( typeof context === "boolean" ) {
+		keepScripts = context;
+		context = false;
+	}
+
+	var base, parsed, scripts;
+
+	if ( !context ) {
+
+		// Stop scripts or inline event handlers from being executed immediately
+		// by using document.implementation
+		if ( support.createHTMLDocument ) {
+			context = document.implementation.createHTMLDocument( "" );
+
+			// Set the base href for the created document
+			// so any parsed elements with URLs
+			// are based on the document's URL (gh-2965)
+			base = context.createElement( "base" );
+			base.href = document.location.href;
+			context.head.appendChild( base );
+		} else {
+			context = document;
+		}
+	}
+
+	parsed = rsingleTag.exec( data );
+	scripts = !keepScripts && [];
+
+	// Single tag
+	if ( parsed ) {
+		return [ context.createElement( parsed[ 1 ] ) ];
+	}
+
+	parsed = buildFragment( [ data ], context, scripts );
+
+	if ( scripts && scripts.length ) {
+		jQuery( scripts ).remove();
+	}
+
+	return jQuery.merge( [], parsed.childNodes );
+};
+
+
+/**
+ * Load a url into a page
+ */
+jQuery.fn.load = function( url, params, callback ) {
+	var selector, type, response,
+		self = this,
+		off = url.indexOf( " " );
+
+	if ( off > -1 ) {
+		selector = stripAndCollapse( url.slice( off ) );
+		url = url.slice( 0, off );
+	}
+
+	// If it's a function
+	if ( isFunction( params ) ) {
+
+		// We assume that it's the callback
+		callback = params;
+		params = undefined;
+
+	// Otherwise, build a param string
+	} else if ( params && typeof params === "object" ) {
+		type = "POST";
+	}
+
+	// If we have elements to modify, make the request
+	if ( self.length > 0 ) {
+		jQuery.ajax( {
+			url: url,
+
+			// If "type" variable is undefined, then "GET" method will be used.
+			// Make value of this field explicit since
+			// user can override it through ajaxSetup method
+			type: type || "GET",
+			dataType: "html",
+			data: params
+		} ).done( function( responseText ) {
+
+			// Save response for use in complete callback
+			response = arguments;
+
+			self.html( selector ?
+
+				// If a selector was specified, locate the right elements in a dummy div
+				// Exclude scripts to avoid IE 'Permission Denied' errors
+				jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
+
+				// Otherwise use the full result
+				responseText );
+
+		// If the request succeeds, this function gets "data", "status", "jqXHR"
+		// but they are ignored because response was set above.
+		// If it fails, this function gets "jqXHR", "status", "error"
+		} ).always( callback && function( jqXHR, status ) {
+			self.each( function() {
+				callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
+			} );
+		} );
+	}
+
+	return this;
+};
+
+
+
+
+jQuery.expr.pseudos.animated = function( elem ) {
+	return jQuery.grep( jQuery.timers, function( fn ) {
+		return elem === fn.elem;
+	} ).length;
+};
+
+
+
+
+jQuery.offset = {
+	setOffset: function( elem, options, i ) {
+		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
+			position = jQuery.css( elem, "position" ),
+			curElem = jQuery( elem ),
+			props = {};
+
+		// Set position first, in-case top/left are set even on static elem
+		if ( position === "static" ) {
+			elem.style.position = "relative";
+		}
+
+		curOffset = curElem.offset();
+		curCSSTop = jQuery.css( elem, "top" );
+		curCSSLeft = jQuery.css( elem, "left" );
+		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
+			( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
+
+		// Need to be able to calculate position if either
+		// top or left is auto and position is either absolute or fixed
+		if ( calculatePosition ) {
+			curPosition = curElem.position();
+			curTop = curPosition.top;
+			curLeft = curPosition.left;
+
+		} else {
+			curTop = parseFloat( curCSSTop ) || 0;
+			curLeft = parseFloat( curCSSLeft ) || 0;
+		}
+
+		if ( isFunction( options ) ) {
+
+			// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
+			options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
+		}
+
+		if ( options.top != null ) {
+			props.top = ( options.top - curOffset.top ) + curTop;
+		}
+		if ( options.left != null ) {
+			props.left = ( options.left - curOffset.left ) + curLeft;
+		}
+
+		if ( "using" in options ) {
+			options.using.call( elem, props );
+
+		} else {
+			curElem.css( props );
+		}
+	}
+};
+
+jQuery.fn.extend( {
+
+	// offset() relates an element's border box to the document origin
+	offset: function( options ) {
+
+		// Preserve chaining for setter
+		if ( arguments.length ) {
+			return options === undefined ?
+				this :
+				this.each( function( i ) {
+					jQuery.offset.setOffset( this, options, i );
+				} );
+		}
+
+		var rect, win,
+			elem = this[ 0 ];
+
+		if ( !elem ) {
+			return;
+		}
+
+		// Return zeros for disconnected and hidden (display: none) elements (gh-2310)
+		// Support: IE <=11 only
+		// Running getBoundingClientRect on a
+		// disconnected node in IE throws an error
+		if ( !elem.getClientRects().length ) {
+			return { top: 0, left: 0 };
+		}
+
+		// Get document-relative position by adding viewport scroll to viewport-relative gBCR
+		rect = elem.getBoundingClientRect();
+		win = elem.ownerDocument.defaultView;
+		return {
+			top: rect.top + win.pageYOffset,
+			left: rect.left + win.pageXOffset
+		};
+	},
+
+	// position() relates an element's margin box to its offset parent's padding box
+	// This corresponds to the behavior of CSS absolute positioning
+	position: function() {
+		if ( !this[ 0 ] ) {
+			return;
+		}
+
+		var offsetParent, offset, doc,
+			elem = this[ 0 ],
+			parentOffset = { top: 0, left: 0 };
+
+		// position:fixed elements are offset from the viewport, which itself always has zero offset
+		if ( jQuery.css( elem, "position" ) === "fixed" ) {
+
+			// Assume position:fixed implies availability of getBoundingClientRect
+			offset = elem.getBoundingClientRect();
+
+		} else {
+			offset = this.offset();
+
+			// Account for the *real* offset parent, which can be the document or its root element
+			// when a statically positioned element is identified
+			doc = elem.ownerDocument;
+			offsetParent = elem.offsetParent || doc.documentElement;
+			while ( offsetParent &&
+				( offsetParent === doc.body || offsetParent === doc.documentElement ) &&
+				jQuery.css( offsetParent, "position" ) === "static" ) {
+
+				offsetParent = offsetParent.parentNode;
+			}
+			if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {
+
+				// Incorporate borders into its offset, since they are outside its content origin
+				parentOffset = jQuery( offsetParent ).offset();
+				parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true );
+				parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true );
+			}
+		}
+
+		// Subtract parent offsets and element margins
+		return {
+			top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
+			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
+		};
+	},
+
+	// This method will return documentElement in the following cases:
+	// 1) For the element inside the iframe without offsetParent, this method will return
+	//    documentElement of the parent window
+	// 2) For the hidden or detached element
+	// 3) For body or html element, i.e. in case of the html node - it will return itself
+	//
+	// but those exceptions were never presented as a real life use-cases
+	// and might be considered as more preferable results.
+	//
+	// This logic, however, is not guaranteed and can change at any point in the future
+	offsetParent: function() {
+		return this.map( function() {
+			var offsetParent = this.offsetParent;
+
+			while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
+				offsetParent = offsetParent.offsetParent;
+			}
+
+			return offsetParent || documentElement;
+		} );
+	}
+} );
+
+// Create scrollLeft and scrollTop methods
+jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
+	var top = "pageYOffset" === prop;
+
+	jQuery.fn[ method ] = function( val ) {
+		return access( this, function( elem, method, val ) {
+
+			// Coalesce documents and windows
+			var win;
+			if ( isWindow( elem ) ) {
+				win = elem;
+			} else if ( elem.nodeType === 9 ) {
+				win = elem.defaultView;
+			}
+
+			if ( val === undefined ) {
+				return win ? win[ prop ] : elem[ method ];
+			}
+
+			if ( win ) {
+				win.scrollTo(
+					!top ? val : win.pageXOffset,
+					top ? val : win.pageYOffset
+				);
+
+			} else {
+				elem[ method ] = val;
+			}
+		}, method, val, arguments.length );
+	};
+} );
+
+// Support: Safari <=7 - 9.1, Chrome <=37 - 49
+// Add the top/left cssHooks using jQuery.fn.position
+// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
+// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
+// getComputedStyle returns percent when specified for top/left/bottom/right;
+// rather than make the css module depend on the offset module, just check for it here
+jQuery.each( [ "top", "left" ], function( _i, prop ) {
+	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
+		function( elem, computed ) {
+			if ( computed ) {
+				computed = curCSS( elem, prop );
+
+				// If curCSS returns percentage, fallback to offset
+				return rnumnonpx.test( computed ) ?
+					jQuery( elem ).position()[ prop ] + "px" :
+					computed;
+			}
+		}
+	);
+} );
+
+
+// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
+jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
+	jQuery.each( {
+		padding: "inner" + name,
+		content: type,
+		"": "outer" + name
+	}, function( defaultExtra, funcName ) {
+
+		// Margin is only for outerHeight, outerWidth
+		jQuery.fn[ funcName ] = function( margin, value ) {
+			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
+				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
+
+			return access( this, function( elem, type, value ) {
+				var doc;
+
+				if ( isWindow( elem ) ) {
+
+					// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
+					return funcName.indexOf( "outer" ) === 0 ?
+						elem[ "inner" + name ] :
+						elem.document.documentElement[ "client" + name ];
+				}
+
+				// Get document width or height
+				if ( elem.nodeType === 9 ) {
+					doc = elem.documentElement;
+
+					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
+					// whichever is greatest
+					return Math.max(
+						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
+						elem.body[ "offset" + name ], doc[ "offset" + name ],
+						doc[ "client" + name ]
+					);
+				}
+
+				return value === undefined ?
+
+					// Get width or height on the element, requesting but not forcing parseFloat
+					jQuery.css( elem, type, extra ) :
+
+					// Set width or height on the element
+					jQuery.style( elem, type, value, extra );
+			}, type, chainable ? margin : undefined, chainable );
+		};
+	} );
+} );
+
+
+jQuery.each( [
+	"ajaxStart",
+	"ajaxStop",
+	"ajaxComplete",
+	"ajaxError",
+	"ajaxSuccess",
+	"ajaxSend"
+], function( _i, type ) {
+	jQuery.fn[ type ] = function( fn ) {
+		return this.on( type, fn );
+	};
+} );
+
+
+
+
+jQuery.fn.extend( {
+
+	bind: function( types, data, fn ) {
+		return this.on( types, null, data, fn );
+	},
+	unbind: function( types, fn ) {
+		return this.off( types, null, fn );
+	},
+
+	delegate: function( selector, types, data, fn ) {
+		return this.on( types, selector, data, fn );
+	},
+	undelegate: function( selector, types, fn ) {
+
+		// ( namespace ) or ( selector, types [, fn] )
+		return arguments.length === 1 ?
+			this.off( selector, "**" ) :
+			this.off( types, selector || "**", fn );
+	},
+
+	hover: function( fnOver, fnOut ) {
+		return this
+			.on( "mouseenter", fnOver )
+			.on( "mouseleave", fnOut || fnOver );
+	}
+} );
+
+jQuery.each(
+	( "blur focus focusin focusout resize scroll click dblclick " +
+	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
+	"change select submit keydown keypress keyup contextmenu" ).split( " " ),
+	function( _i, name ) {
+
+		// Handle event binding
+		jQuery.fn[ name ] = function( data, fn ) {
+			return arguments.length > 0 ?
+				this.on( name, null, data, fn ) :
+				this.trigger( name );
+		};
+	}
+);
+
+
+
+
+// Support: Android <=4.0 only
+// Make sure we trim BOM and NBSP
+// Require that the "whitespace run" starts from a non-whitespace
+// to avoid O(N^2) behavior when the engine would try matching "\s+$" at each space position.
+var rtrim = /^[\s\uFEFF\xA0]+|([^\s\uFEFF\xA0])[\s\uFEFF\xA0]+$/g;
+
+// Bind a function to a context, optionally partially applying any
+// arguments.
+// jQuery.proxy is deprecated to promote standards (specifically Function#bind)
+// However, it is not slated for removal any time soon
+jQuery.proxy = function( fn, context ) {
+	var tmp, args, proxy;
+
+	if ( typeof context === "string" ) {
+		tmp = fn[ context ];
+		context = fn;
+		fn = tmp;
+	}
+
+	// Quick check to determine if target is callable, in the spec
+	// this throws a TypeError, but we will just return undefined.
+	if ( !isFunction( fn ) ) {
+		return undefined;
+	}
+
+	// Simulated bind
+	args = slice.call( arguments, 2 );
+	proxy = function() {
+		return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
+	};
+
+	// Set the guid of unique handler to the same of original handler, so it can be removed
+	proxy.guid = fn.guid = fn.guid || jQuery.guid++;
+
+	return proxy;
+};
+
+jQuery.holdReady = function( hold ) {
+	if ( hold ) {
+		jQuery.readyWait++;
+	} else {
+		jQuery.ready( true );
+	}
+};
+jQuery.isArray = Array.isArray;
+jQuery.parseJSON = JSON.parse;
+jQuery.nodeName = nodeName;
+jQuery.isFunction = isFunction;
+jQuery.isWindow = isWindow;
+jQuery.camelCase = camelCase;
+jQuery.type = toType;
+
+jQuery.now = Date.now;
+
+jQuery.isNumeric = function( obj ) {
+
+	// As of jQuery 3.0, isNumeric is limited to
+	// strings and numbers (primitives or objects)
+	// that can be coerced to finite numbers (gh-2662)
+	var type = jQuery.type( obj );
+	return ( type === "number" || type === "string" ) &&
+
+		// parseFloat NaNs numeric-cast false positives ("")
+		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
+		// subtraction forces infinities to NaN
+		!isNaN( obj - parseFloat( obj ) );
+};
+
+jQuery.trim = function( text ) {
+	return text == null ?
+		"" :
+		( text + "" ).replace( rtrim, "$1" );
+};
+
+
+
+// Register as a named AMD module, since jQuery can be concatenated with other
+// files that may use define, but not via a proper concatenation script that
+// understands anonymous AMD modules. A named AMD is safest and most robust
+// way to register. Lowercase jquery is used because AMD module names are
+// derived from file names, and jQuery is normally delivered in a lowercase
+// file name. Do this after creating the global so that if an AMD module wants
+// to call noConflict to hide this version of jQuery, it will work.
+
+// Note that for maximum portability, libraries that are not jQuery should
+// declare themselves as anonymous modules, and avoid setting a global if an
+// AMD loader is present. jQuery is a special case. For more information, see
+// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
+
+if ( typeof define === "function" && define.amd ) {
+	define( "jquery", [], function() {
+		return jQuery;
+	} );
+}
+
+
+
+
+var
+
+	// Map over jQuery in case of overwrite
+	_jQuery = window.jQuery,
+
+	// Map over the $ in case of overwrite
+	_$ = window.$;
+
+jQuery.noConflict = function( deep ) {
+	if ( window.$ === jQuery ) {
+		window.$ = _$;
+	}
+
+	if ( deep && window.jQuery === jQuery ) {
+		window.jQuery = _jQuery;
+	}
+
+	return jQuery;
+};
+
+// Expose jQuery and $ identifiers, even in AMD
+// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557)
+// and CommonJS for browser emulators (trac-13566)
+if ( typeof noGlobal === "undefined" ) {
+	window.jQuery = window.$ = jQuery;
+}
+
+
+
+
+return jQuery;
+} );
\ No newline at end of file
diff --git a/android/src/main/assets/js/main.js b/android/src/main/assets/js/main.js
new file mode 100644
index 000000000..e69de29bb
diff --git a/android/src/main/assets/success.html b/android/src/main/assets/success.html
new file mode 100644
index 000000000..3d83c4374
--- /dev/null
+++ b/android/src/main/assets/success.html
@@ -0,0 +1,11 @@
+<html>
+<head>
+  <link href="css/style.css" rel="stylesheet"/>
+  <script src="js/jquery-3.7.1.js" type="text/javascript"></script>
+  <script src="js/main.js" type="text/javascript"></script>
+  <title>Upload Success</title>
+</head>
+<body>
+<div class="title">Upload Success</div>
+</body>
+</html>
\ No newline at end of file
diff --git a/android/src/main/java/com/descent3/droid/GameDataUploadActivity.java b/android/src/main/java/com/descent3/droid/GameDataUploadActivity.java
new file mode 100644
index 000000000..0011d52fb
--- /dev/null
+++ b/android/src/main/java/com/descent3/droid/GameDataUploadActivity.java
@@ -0,0 +1,219 @@
+package com.descent3.droid;
+
+import static fi.iki.elonen.NanoHTTPD.Response.Status.BAD_REQUEST;
+import static fi.iki.elonen.NanoHTTPD.Response.Status.INTERNAL_ERROR;
+import static fi.iki.elonen.NanoHTTPD.Response.Status.METHOD_NOT_ALLOWED;
+import static fi.iki.elonen.NanoHTTPD.Response.Status.NOT_FOUND;
+import static fi.iki.elonen.NanoHTTPD.Response.Status.OK;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.content.res.AssetManager;
+import android.os.Bundle;
+import android.text.Html;
+import android.util.Log;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import fi.iki.elonen.NanoHTTPD;
+
+public class GameDataUploadActivity extends Activity {
+  private GameDataHttpServer mServer;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    mServer = new GameDataHttpServer(
+      getAssets(),
+      getCacheDir().toPath().resolve("gamedata"),
+      () -> {
+        // TODO: there's gonna be a race here; should explicitly have the Success html trigger this?
+        startActivity(new Intent(this, MainActivity.class));
+        finish();
+      });
+
+    setContentView(R.layout.game_data_layout_activity);
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    try {
+      mServer.start();
+    } catch (IOException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Override
+  protected void onStop() {
+    super.onStop();
+    mServer.stop();
+  }
+
+  private static class GameDataHttpServer extends NanoHTTPD {
+    private static final String INTERNAL_ERROR_STRING =
+      "<html>" +
+        "<head><title>Internal Error</title></head>" +
+        "<body><center>" +
+        "<h1>Internal Error</h1>" +
+        "<div>%s</div>" +
+        "</center></body>" +
+        "</html>";
+    private final AssetManager mAssetManager;
+    private final Path mGameDataDir;
+    private final Runnable mOnUploadSuccess;
+
+    GameDataHttpServer(AssetManager assetManager, Path gameDataDir, Runnable onUploadSuccess) {
+      super(null, 6464);
+      mAssetManager = assetManager;
+      mGameDataDir = gameDataDir;
+      mOnUploadSuccess = onUploadSuccess;
+
+      setTempFileManagerFactory(() -> {
+        try {
+          return new GameDataTempFileManager();
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+      });
+    }
+
+    private static void deleteAll(Path dir) {
+      if (!Files.exists(dir)) {
+        return;
+      }
+
+      try (Stream<Path> dirStream = Files.walk(dir)) {
+        dirStream
+          .sorted(Comparator.reverseOrder())
+          .map(Path::toFile)
+          .filter(f -> !f.delete())
+          .forEach(f -> Log.w("csarbora", "Failed to delete " + f.getAbsolutePath()));
+      } catch (IOException e) {
+        Log.e("csarbora", "unable to walk " + dir.toAbsolutePath(), e);
+      }
+    }
+
+    @Override
+    public Response serve(IHTTPSession session) {
+      try {
+        switch (session.getMethod()) {
+          case GET: {
+            try {
+              return assetResponse(OK, session.getUri());
+            } catch (IOException e) {
+              return assetResponse(NOT_FOUND, "/errors/404.html");
+            }
+          }
+          case POST: {
+            deleteAll(mGameDataDir);
+
+            HashMap<String, String> files = new HashMap<>();
+            try {
+              session.parseBody(files);
+            } catch (ResponseException e) {
+              throw new IOException(e);
+            }
+
+            Optional<Path> base = files.values().stream()
+              .filter(path -> path.endsWith("d3.hog"))
+              .findAny()
+              .map(Paths::get)
+              .map(Path::getParent);
+
+            if (!base.isPresent()) {
+              return assetResponse(BAD_REQUEST, "/errors/400_no_d3hog.html");
+            }
+
+            Files.move(base.get(), mGameDataDir);
+            mOnUploadSuccess.run();
+            return assetResponse(OK, "/success.html");
+          }
+          default:
+            return assetResponse(METHOD_NOT_ALLOWED, "/errors/405.html");
+        }
+      } catch (IOException e) {
+        return newFixedLengthResponse(
+          INTERNAL_ERROR,
+          "text/html",
+          String.format(INTERNAL_ERROR_STRING, Html.escapeHtml(e.toString())));
+      }
+    }
+
+    private Response assetResponse(Response.Status status, String uri) throws IOException {
+      uri = uri.substring(1);
+      if (uri.isEmpty()) {
+        uri = "index.html";
+      }
+
+      return newChunkedResponse(
+        status,
+        getMimeTypeForFile(uri),
+        mAssetManager.open(uri, AssetManager.ACCESS_STREAMING));
+    }
+
+    private static class GameDataFile implements TempFile {
+      private final Path mPath;
+
+      public GameDataFile(Path base, String filename) throws IOException {
+        if (filename != null) {
+          mPath = base.resolve(filename);
+          Files.createDirectories(mPath.getParent());
+          mPath.getParent().toFile().mkdirs();
+        } else {
+          mPath = Files.createTempFile(base, "tmp", null);
+        }
+      }
+
+      @Override
+      public void delete() {
+        try {
+          Files.delete(mPath);
+        } catch (IOException ignored) {
+        }
+      }
+
+      @Override
+      public String getName() {
+        return mPath.toAbsolutePath().toString();
+      }
+
+      @Override
+      public OutputStream open() throws Exception {
+        return Files.newOutputStream(mPath);
+      }
+    }
+
+    private static class GameDataTempFileManager implements TempFileManager {
+      private final Path mBase;
+
+      GameDataTempFileManager() throws IOException {
+        mBase = Files.createTempDirectory("gamedata");
+      }
+
+      @Override
+      public void clear() {
+        deleteAll(mBase);
+      }
+
+      @Override
+      public TempFile createTempFile(String filename_hint) throws IOException {
+        return new GameDataFile(mBase, filename_hint);
+      }
+
+      public Path getBase() {
+        return mBase;
+      }
+    }
+  }
+}
diff --git a/android/src/main/java/com/descent3/droid/MainActivity.java b/android/src/main/java/com/descent3/droid/MainActivity.java
new file mode 100644
index 000000000..bc3aee61b
--- /dev/null
+++ b/android/src/main/java/com/descent3/droid/MainActivity.java
@@ -0,0 +1,57 @@
+package com.descent3.droid;
+
+import android.content.Intent;
+import android.os.Bundle;
+
+import org.libsdl.app.SDLActivity;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class MainActivity extends SDLActivity {
+
+  private Path mFilesGameData;
+  private Path mCacheGameData;
+  private Path mTempDir;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+
+    try {
+      mFilesGameData = getFilesDir().toPath().resolve("gamedata");
+      Files.createDirectories(mFilesGameData);
+      mCacheGameData = getCacheDir().toPath().resolve("gamedata");
+      mTempDir = Files.createTempDirectory("d3");
+    } catch (IOException ex) {
+      throw new RuntimeException(ex);
+    }
+
+    if (!mCacheGameData.resolve("d3.hog").toFile().exists()) {
+      startActivity(new Intent(this, GameDataUploadActivity.class));
+      finish();
+    }
+  }
+
+  @Override
+  protected String[] getLibraries() {
+    return new String[]{
+      "Descent3",
+    };
+  }
+
+  @Override
+  protected String[] getArguments() {
+    ArrayList<String> args = new ArrayList<>(Arrays.asList(super.getArguments()));
+    args.add("-setdir");
+    args.add(mFilesGameData.toAbsolutePath().toString());
+    args.add("-additionaldir");
+    args.add(mCacheGameData.toAbsolutePath().toString());
+    args.add("-tempdir");
+    args.add(mTempDir.toAbsolutePath().toString());
+    return args.toArray(new String[0]);
+  }
+}
diff --git a/android/src/main/java/org/libsdl/app/HIDDevice.java b/android/src/main/java/org/libsdl/app/HIDDevice.java
new file mode 100644
index 000000000..f7bc6fd46
--- /dev/null
+++ b/android/src/main/java/org/libsdl/app/HIDDevice.java
@@ -0,0 +1,35 @@
+package org.libsdl.app;
+
+import android.hardware.usb.UsbDevice;
+
+interface HIDDevice {
+  int getId();
+
+  int getVendorId();
+
+  int getProductId();
+
+  String getSerialNumber();
+
+  int getVersion();
+
+  String getManufacturerName();
+
+  String getProductName();
+
+  UsbDevice getDevice();
+
+  boolean open();
+
+  int sendFeatureReport(byte[] report);
+
+  int sendOutputReport(byte[] report);
+
+  boolean getFeatureReport(byte[] report);
+
+  void setFrozen(boolean frozen);
+
+  void close();
+
+  void shutdown();
+}
diff --git a/android/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java b/android/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java
new file mode 100644
index 000000000..0bf1953a3
--- /dev/null
+++ b/android/src/main/java/org/libsdl/app/HIDDeviceBLESteamController.java
@@ -0,0 +1,638 @@
+package org.libsdl.app;
+
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothGatt;
+import android.bluetooth.BluetoothGattCallback;
+import android.bluetooth.BluetoothGattCharacteristic;
+import android.bluetooth.BluetoothGattDescriptor;
+import android.bluetooth.BluetoothGattService;
+import android.bluetooth.BluetoothManager;
+import android.bluetooth.BluetoothProfile;
+import android.content.Context;
+import android.hardware.usb.UsbDevice;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.UUID;
+
+class HIDDeviceBLESteamController extends BluetoothGattCallback implements HIDDevice {
+
+  static public final UUID steamControllerService = UUID.fromString("100F6C32-1735-4313-B402-38567131E5F3");
+  static public final UUID inputCharacteristic = UUID.fromString("100F6C33-1735-4313-B402-38567131E5F3");
+  static public final UUID reportCharacteristic = UUID.fromString("100F6C34-1735-4313-B402-38567131E5F3");
+  private static final String TAG = "hidapi";
+  private static final int TRANSPORT_AUTO = 0;
+  private static final int TRANSPORT_BREDR = 1;
+  private static final int TRANSPORT_LE = 2;
+  private static final int CHROMEBOOK_CONNECTION_CHECK_INTERVAL = 10000;
+  static private final byte[] enterValveMode = new byte[]{(byte) 0xC0, (byte) 0x87, 0x03, 0x08, 0x07, 0x00};
+  GattOperation mCurrentOperation = null;
+  private HIDDeviceManager mManager;
+  private final BluetoothDevice mDevice;
+  private final int mDeviceId;
+  private BluetoothGatt mGatt;
+  private boolean mIsRegistered = false;
+  private boolean mIsConnected = false;
+  private boolean mIsChromebook = false;
+  private boolean mIsReconnecting = false;
+  private boolean mFrozen = false;
+  private final LinkedList<GattOperation> mOperations;
+  private final Handler mHandler;
+
+  public HIDDeviceBLESteamController(HIDDeviceManager manager, BluetoothDevice device) {
+    mManager = manager;
+    mDevice = device;
+    mDeviceId = mManager.getDeviceIDForIdentifier(getIdentifier());
+    mIsRegistered = false;
+    mIsChromebook = mManager.getContext().getPackageManager().hasSystemFeature("org.chromium.arc.device_management");
+    mOperations = new LinkedList<GattOperation>();
+    mHandler = new Handler(Looper.getMainLooper());
+
+    mGatt = connectGatt();
+    // final HIDDeviceBLESteamController finalThis = this;
+    // mHandler.postDelayed(new Runnable() {
+    //     @Override
+    //     public void run() {
+    //         finalThis.checkConnectionForChromebookIssue();
+    //     }
+    // }, CHROMEBOOK_CONNECTION_CHECK_INTERVAL);
+  }
+
+  public String getIdentifier() {
+    return String.format("SteamController.%s", mDevice.getAddress());
+  }
+
+  public BluetoothGatt getGatt() {
+    return mGatt;
+  }
+
+  // Because on Chromebooks we show up as a dual-mode device, it will attempt to connect TRANSPORT_AUTO, which will use TRANSPORT_BREDR instead
+  // of TRANSPORT_LE.  Let's force ourselves to connect low energy.
+  private BluetoothGatt connectGatt(boolean managed) {
+    if (Build.VERSION.SDK_INT >= 23 /* Android 6.0 (M) */) {
+      try {
+        return mDevice.connectGatt(mManager.getContext(), managed, this, TRANSPORT_LE);
+      } catch (Exception e) {
+        return mDevice.connectGatt(mManager.getContext(), managed, this);
+      }
+    } else {
+      return mDevice.connectGatt(mManager.getContext(), managed, this);
+    }
+  }
+
+  private BluetoothGatt connectGatt() {
+    return connectGatt(false);
+  }
+
+  protected int getConnectionState() {
+
+    Context context = mManager.getContext();
+    if (context == null) {
+      // We are lacking any context to get our Bluetooth information.  We'll just assume disconnected.
+      return BluetoothProfile.STATE_DISCONNECTED;
+    }
+
+    BluetoothManager btManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
+    if (btManager == null) {
+      // This device doesn't support Bluetooth.  We should never be here, because how did
+      // we instantiate a device to start with?
+      return BluetoothProfile.STATE_DISCONNECTED;
+    }
+
+    return btManager.getConnectionState(mDevice, BluetoothProfile.GATT);
+  }
+
+  public void reconnect() {
+
+    if (getConnectionState() != BluetoothProfile.STATE_CONNECTED) {
+      mGatt.disconnect();
+      mGatt = connectGatt();
+    }
+
+  }
+
+  protected void checkConnectionForChromebookIssue() {
+    if (!mIsChromebook) {
+      // We only do this on Chromebooks, because otherwise it's really annoying to just attempt
+      // over and over.
+      return;
+    }
+
+    int connectionState = getConnectionState();
+
+    switch (connectionState) {
+      case BluetoothProfile.STATE_CONNECTED:
+        if (!mIsConnected) {
+          // We are in the Bad Chromebook Place.  We can force a disconnect
+          // to try to recover.
+          Log.v(TAG, "Chromebook: We are in a very bad state; the controller shows as connected in the underlying Bluetooth layer, but we never received a callback.  Forcing a reconnect.");
+          mIsReconnecting = true;
+          mGatt.disconnect();
+          mGatt = connectGatt(false);
+          break;
+        } else if (!isRegistered()) {
+          if (mGatt.getServices().size() > 0) {
+            Log.v(TAG, "Chromebook: We are connected to a controller, but never got our registration.  Trying to recover.");
+            probeService(this);
+          } else {
+            Log.v(TAG, "Chromebook: We are connected to a controller, but never discovered services.  Trying to recover.");
+            mIsReconnecting = true;
+            mGatt.disconnect();
+            mGatt = connectGatt(false);
+            break;
+          }
+        } else {
+          Log.v(TAG, "Chromebook: We are connected, and registered.  Everything's good!");
+          return;
+        }
+        break;
+
+      case BluetoothProfile.STATE_DISCONNECTED:
+        Log.v(TAG, "Chromebook: We have either been disconnected, or the Chromebook BtGatt.ContextMap bug has bitten us.  Attempting a disconnect/reconnect, but we may not be able to recover.");
+
+        mIsReconnecting = true;
+        mGatt.disconnect();
+        mGatt = connectGatt(false);
+        break;
+
+      case BluetoothProfile.STATE_CONNECTING:
+        Log.v(TAG, "Chromebook: We're still trying to connect.  Waiting a bit longer.");
+        break;
+    }
+
+    final HIDDeviceBLESteamController finalThis = this;
+    mHandler.postDelayed(new Runnable() {
+      @Override
+      public void run() {
+        finalThis.checkConnectionForChromebookIssue();
+      }
+    }, CHROMEBOOK_CONNECTION_CHECK_INTERVAL);
+  }
+
+  private boolean isRegistered() {
+    return mIsRegistered;
+  }
+
+  private void setRegistered() {
+    mIsRegistered = true;
+  }
+
+  private boolean probeService(HIDDeviceBLESteamController controller) {
+
+    if (isRegistered()) {
+      return true;
+    }
+
+    if (!mIsConnected) {
+      return false;
+    }
+
+    Log.v(TAG, "probeService controller=" + controller);
+
+    for (BluetoothGattService service : mGatt.getServices()) {
+      if (service.getUuid().equals(steamControllerService)) {
+        Log.v(TAG, "Found Valve steam controller service " + service.getUuid());
+
+        for (BluetoothGattCharacteristic chr : service.getCharacteristics()) {
+          if (chr.getUuid().equals(inputCharacteristic)) {
+            Log.v(TAG, "Found input characteristic");
+            // Start notifications
+            BluetoothGattDescriptor cccd = chr.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
+            if (cccd != null) {
+              enableNotification(chr.getUuid());
+            }
+          }
+        }
+        return true;
+      }
+    }
+
+    if ((mGatt.getServices().size() == 0) && mIsChromebook && !mIsReconnecting) {
+      Log.e(TAG, "Chromebook: Discovered services were empty; this almost certainly means the BtGatt.ContextMap bug has bitten us.");
+      mIsConnected = false;
+      mIsReconnecting = true;
+      mGatt.disconnect();
+      mGatt = connectGatt(false);
+    }
+
+    return false;
+  }
+
+  private void finishCurrentGattOperation() {
+    GattOperation op = null;
+    synchronized (mOperations) {
+      if (mCurrentOperation != null) {
+        op = mCurrentOperation;
+        mCurrentOperation = null;
+      }
+    }
+    if (op != null) {
+      boolean result = op.finish(); // TODO: Maybe in main thread as well?
+
+      // Our operation failed, let's add it back to the beginning of our queue.
+      if (!result) {
+        mOperations.addFirst(op);
+      }
+    }
+    executeNextGattOperation();
+  }
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private void executeNextGattOperation() {
+    synchronized (mOperations) {
+      if (mCurrentOperation != null)
+        return;
+
+      if (mOperations.isEmpty())
+        return;
+
+      mCurrentOperation = mOperations.removeFirst();
+    }
+
+    // Run in main thread
+    mHandler.post(new Runnable() {
+      @Override
+      public void run() {
+        synchronized (mOperations) {
+          if (mCurrentOperation == null) {
+            Log.e(TAG, "Current operation null in executor?");
+            return;
+          }
+
+          mCurrentOperation.run();
+          // now wait for the GATT callback and when it comes, finish this operation
+        }
+      }
+    });
+  }
+
+  private void queueGattOperation(GattOperation op) {
+    synchronized (mOperations) {
+      mOperations.add(op);
+    }
+    executeNextGattOperation();
+  }
+
+  private void enableNotification(UUID chrUuid) {
+    GattOperation op = HIDDeviceBLESteamController.GattOperation.enableNotification(mGatt, chrUuid);
+    queueGattOperation(op);
+  }
+
+  public void writeCharacteristic(UUID uuid, byte[] value) {
+    GattOperation op = HIDDeviceBLESteamController.GattOperation.writeCharacteristic(mGatt, uuid, value);
+    queueGattOperation(op);
+  }
+
+  public void readCharacteristic(UUID uuid) {
+    GattOperation op = HIDDeviceBLESteamController.GattOperation.readCharacteristic(mGatt, uuid);
+    queueGattOperation(op);
+  }
+
+  public void onConnectionStateChange(BluetoothGatt g, int status, int newState) {
+    //Log.v(TAG, "onConnectionStateChange status=" + status + " newState=" + newState);
+    mIsReconnecting = false;
+    if (newState == 2) {
+      mIsConnected = true;
+      // Run directly, without GattOperation
+      if (!isRegistered()) {
+        mHandler.post(new Runnable() {
+          @Override
+          public void run() {
+            mGatt.discoverServices();
+          }
+        });
+      }
+    } else if (newState == 0) {
+      mIsConnected = false;
+    }
+
+    // Disconnection is handled in SteamLink using the ACTION_ACL_DISCONNECTED Intent.
+  }
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////  BluetoothGattCallback overridden methods
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public void onServicesDiscovered(BluetoothGatt gatt, int status) {
+    //Log.v(TAG, "onServicesDiscovered status=" + status);
+    if (status == 0) {
+      if (gatt.getServices().size() == 0) {
+        Log.v(TAG, "onServicesDiscovered returned zero services; something has gone horribly wrong down in Android's Bluetooth stack.");
+        mIsReconnecting = true;
+        mIsConnected = false;
+        gatt.disconnect();
+        mGatt = connectGatt(false);
+      } else {
+        probeService(this);
+      }
+    }
+  }
+
+  public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
+    //Log.v(TAG, "onCharacteristicRead status=" + status + " uuid=" + characteristic.getUuid());
+
+    if (characteristic.getUuid().equals(reportCharacteristic) && !mFrozen) {
+      mManager.HIDDeviceFeatureReport(getId(), characteristic.getValue());
+    }
+
+    finishCurrentGattOperation();
+  }
+
+  public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
+    //Log.v(TAG, "onCharacteristicWrite status=" + status + " uuid=" + characteristic.getUuid());
+
+    if (characteristic.getUuid().equals(reportCharacteristic)) {
+      // Only register controller with the native side once it has been fully configured
+      if (!isRegistered()) {
+        Log.v(TAG, "Registering Steam Controller with ID: " + getId());
+        mManager.HIDDeviceConnected(getId(), getIdentifier(), getVendorId(), getProductId(), getSerialNumber(), getVersion(), getManufacturerName(), getProductName(), 0, 0, 0, 0);
+        setRegistered();
+      }
+    }
+
+    finishCurrentGattOperation();
+  }
+
+  public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
+    // Enable this for verbose logging of controller input reports
+    //Log.v(TAG, "onCharacteristicChanged uuid=" + characteristic.getUuid() + " data=" + HexDump.dumpHexString(characteristic.getValue()));
+
+    if (characteristic.getUuid().equals(inputCharacteristic) && !mFrozen) {
+      mManager.HIDDeviceInputReport(getId(), characteristic.getValue());
+    }
+  }
+
+  public void onDescriptorRead(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
+    //Log.v(TAG, "onDescriptorRead status=" + status);
+  }
+
+  public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
+    BluetoothGattCharacteristic chr = descriptor.getCharacteristic();
+    //Log.v(TAG, "onDescriptorWrite status=" + status + " uuid=" + chr.getUuid() + " descriptor=" + descriptor.getUuid());
+
+    if (chr.getUuid().equals(inputCharacteristic)) {
+      boolean hasWrittenInputDescriptor = true;
+      BluetoothGattCharacteristic reportChr = chr.getService().getCharacteristic(reportCharacteristic);
+      if (reportChr != null) {
+        Log.v(TAG, "Writing report characteristic to enter valve mode");
+        reportChr.setValue(enterValveMode);
+        gatt.writeCharacteristic(reportChr);
+      }
+    }
+
+    finishCurrentGattOperation();
+  }
+
+  public void onReliableWriteCompleted(BluetoothGatt gatt, int status) {
+    //Log.v(TAG, "onReliableWriteCompleted status=" + status);
+  }
+
+  public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
+    //Log.v(TAG, "onReadRemoteRssi status=" + status);
+  }
+
+  public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
+    //Log.v(TAG, "onMtuChanged status=" + status);
+  }
+
+  @Override
+  public int getId() {
+    return mDeviceId;
+  }
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+  //////// Public API
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  @Override
+  public int getVendorId() {
+    // Valve Corporation
+    final int VALVE_USB_VID = 0x28DE;
+    return VALVE_USB_VID;
+  }
+
+  @Override
+  public int getProductId() {
+    // We don't have an easy way to query from the Bluetooth device, but we know what it is
+    final int D0G_BLE2_PID = 0x1106;
+    return D0G_BLE2_PID;
+  }
+
+  @Override
+  public String getSerialNumber() {
+    // This will be read later via feature report by Steam
+    return "12345";
+  }
+
+  @Override
+  public int getVersion() {
+    return 0;
+  }
+
+  @Override
+  public String getManufacturerName() {
+    return "Valve Corporation";
+  }
+
+  @Override
+  public String getProductName() {
+    return "Steam Controller";
+  }
+
+  @Override
+  public UsbDevice getDevice() {
+    return null;
+  }
+
+  @Override
+  public boolean open() {
+    return true;
+  }
+
+  @Override
+  public int sendFeatureReport(byte[] report) {
+    if (!isRegistered()) {
+      Log.e(TAG, "Attempted sendFeatureReport before Steam Controller is registered!");
+      if (mIsConnected) {
+        probeService(this);
+      }
+      return -1;
+    }
+
+    // We need to skip the first byte, as that doesn't go over the air
+    byte[] actual_report = Arrays.copyOfRange(report, 1, report.length - 1);
+    //Log.v(TAG, "sendFeatureReport " + HexDump.dumpHexString(actual_report));
+    writeCharacteristic(reportCharacteristic, actual_report);
+    return report.length;
+  }
+
+  @Override
+  public int sendOutputReport(byte[] report) {
+    if (!isRegistered()) {
+      Log.e(TAG, "Attempted sendOutputReport before Steam Controller is registered!");
+      if (mIsConnected) {
+        probeService(this);
+      }
+      return -1;
+    }
+
+    //Log.v(TAG, "sendFeatureReport " + HexDump.dumpHexString(report));
+    writeCharacteristic(reportCharacteristic, report);
+    return report.length;
+  }
+
+  @Override
+  public boolean getFeatureReport(byte[] report) {
+    if (!isRegistered()) {
+      Log.e(TAG, "Attempted getFeatureReport before Steam Controller is registered!");
+      if (mIsConnected) {
+        probeService(this);
+      }
+      return false;
+    }
+
+    //Log.v(TAG, "getFeatureReport");
+    readCharacteristic(reportCharacteristic);
+    return true;
+  }
+
+  @Override
+  public void close() {
+  }
+
+  @Override
+  public void setFrozen(boolean frozen) {
+    mFrozen = frozen;
+  }
+
+  @Override
+  public void shutdown() {
+    close();
+
+    BluetoothGatt g = mGatt;
+    if (g != null) {
+      g.disconnect();
+      g.close();
+      mGatt = null;
+    }
+    mManager = null;
+    mIsRegistered = false;
+    mIsConnected = false;
+    mOperations.clear();
+  }
+
+  static class GattOperation {
+    Operation mOp;
+    UUID mUuid;
+    byte[] mValue;
+    BluetoothGatt mGatt;
+    boolean mResult = true;
+    private GattOperation(BluetoothGatt gatt, GattOperation.Operation operation, UUID uuid) {
+      mGatt = gatt;
+      mOp = operation;
+      mUuid = uuid;
+    }
+
+    private GattOperation(BluetoothGatt gatt, GattOperation.Operation operation, UUID uuid, byte[] value) {
+      mGatt = gatt;
+      mOp = operation;
+      mUuid = uuid;
+      mValue = value;
+    }
+
+    static public GattOperation readCharacteristic(BluetoothGatt gatt, UUID uuid) {
+      return new GattOperation(gatt, Operation.CHR_READ, uuid);
+    }
+
+    static public GattOperation writeCharacteristic(BluetoothGatt gatt, UUID uuid, byte[] value) {
+      return new GattOperation(gatt, Operation.CHR_WRITE, uuid, value);
+    }
+
+    static public GattOperation enableNotification(BluetoothGatt gatt, UUID uuid) {
+      return new GattOperation(gatt, Operation.ENABLE_NOTIFICATION, uuid);
+    }
+
+    public void run() {
+      // This is executed in main thread
+      BluetoothGattCharacteristic chr;
+
+      switch (mOp) {
+        case CHR_READ:
+          chr = getCharacteristic(mUuid);
+          //Log.v(TAG, "Reading characteristic " + chr.getUuid());
+          if (!mGatt.readCharacteristic(chr)) {
+            Log.e(TAG, "Unable to read characteristic " + mUuid.toString());
+            mResult = false;
+            break;
+          }
+          mResult = true;
+          break;
+        case CHR_WRITE:
+          chr = getCharacteristic(mUuid);
+          //Log.v(TAG, "Writing characteristic " + chr.getUuid() + " value=" + HexDump.toHexString(value));
+          chr.setValue(mValue);
+          if (!mGatt.writeCharacteristic(chr)) {
+            Log.e(TAG, "Unable to write characteristic " + mUuid.toString());
+            mResult = false;
+            break;
+          }
+          mResult = true;
+          break;
+        case ENABLE_NOTIFICATION:
+          chr = getCharacteristic(mUuid);
+          //Log.v(TAG, "Writing descriptor of " + chr.getUuid());
+          if (chr != null) {
+            BluetoothGattDescriptor cccd = chr.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
+            if (cccd != null) {
+              int properties = chr.getProperties();
+              byte[] value;
+              if ((properties & BluetoothGattCharacteristic.PROPERTY_NOTIFY) == BluetoothGattCharacteristic.PROPERTY_NOTIFY) {
+                value = BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE;
+              } else if ((properties & BluetoothGattCharacteristic.PROPERTY_INDICATE) == BluetoothGattCharacteristic.PROPERTY_INDICATE) {
+                value = BluetoothGattDescriptor.ENABLE_INDICATION_VALUE;
+              } else {
+                Log.e(TAG, "Unable to start notifications on input characteristic");
+                mResult = false;
+                return;
+              }
+
+              mGatt.setCharacteristicNotification(chr, true);
+              cccd.setValue(value);
+              if (!mGatt.writeDescriptor(cccd)) {
+                Log.e(TAG, "Unable to write descriptor " + mUuid.toString());
+                mResult = false;
+                return;
+              }
+              mResult = true;
+            }
+          }
+      }
+    }
+
+    public boolean finish() {
+      return mResult;
+    }
+
+    private BluetoothGattCharacteristic getCharacteristic(UUID uuid) {
+      BluetoothGattService valveService = mGatt.getService(steamControllerService);
+      if (valveService == null)
+        return null;
+      return valveService.getCharacteristic(uuid);
+    }
+
+    private enum Operation {
+      CHR_READ,
+      CHR_WRITE,
+      ENABLE_NOTIFICATION
+    }
+  }
+
+}
+
diff --git a/android/src/main/java/org/libsdl/app/HIDDeviceManager.java b/android/src/main/java/org/libsdl/app/HIDDeviceManager.java
new file mode 100644
index 000000000..e618dca47
--- /dev/null
+++ b/android/src/main/java/org/libsdl/app/HIDDeviceManager.java
@@ -0,0 +1,696 @@
+package org.libsdl.app;
+
+import android.app.PendingIntent;
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothManager;
+import android.bluetooth.BluetoothProfile;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.content.SharedPreferences;
+import android.content.pm.PackageManager;
+import android.hardware.usb.UsbConstants;
+import android.hardware.usb.UsbDevice;
+import android.hardware.usb.UsbInterface;
+import android.hardware.usb.UsbManager;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class HIDDeviceManager {
+  private static final String TAG = "hidapi";
+  private static final String ACTION_USB_PERMISSION = "org.libsdl.app.USB_PERMISSION";
+
+  private static HIDDeviceManager sManager;
+  private static int sManagerRefCount = 0;
+  private final Context mContext;
+  private final HashMap<Integer, HIDDevice> mDevicesById = new HashMap<Integer, HIDDevice>();
+  private final BroadcastReceiver mUsbBroadcast = new BroadcastReceiver() {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      String action = intent.getAction();
+      if (action.equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)) {
+        UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
+        handleUsbDeviceAttached(usbDevice);
+      } else if (action.equals(UsbManager.ACTION_USB_DEVICE_DETACHED)) {
+        UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
+        handleUsbDeviceDetached(usbDevice);
+      } else if (action.equals(HIDDeviceManager.ACTION_USB_PERMISSION)) {
+        UsbDevice usbDevice = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
+        handleUsbDevicePermission(usbDevice, intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false));
+      }
+    }
+  };
+  private final HashMap<BluetoothDevice, HIDDeviceBLESteamController> mBluetoothDevices = new HashMap<BluetoothDevice, HIDDeviceBLESteamController>();
+  private final BroadcastReceiver mBluetoothBroadcast = new BroadcastReceiver() {
+    @Override
+    public void onReceive(Context context, Intent intent) {
+      String action = intent.getAction();
+      // Bluetooth device was connected. If it was a Steam Controller, handle it
+      if (action.equals(BluetoothDevice.ACTION_ACL_CONNECTED)) {
+        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+        Log.d(TAG, "Bluetooth device connected: " + device);
+
+        if (isSteamController(device)) {
+          connectBluetoothDevice(device);
+        }
+      }
+
+      // Bluetooth device was disconnected, remove from controller manager (if any)
+      if (action.equals(BluetoothDevice.ACTION_ACL_DISCONNECTED)) {
+        BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
+        Log.d(TAG, "Bluetooth device disconnected: " + device);
+
+        disconnectBluetoothDevice(device);
+      }
+    }
+  };
+  private int mNextDeviceId = 0;
+  private SharedPreferences mSharedPreferences = null;
+  private boolean mIsChromebook = false;
+  private UsbManager mUsbManager;
+  private Handler mHandler;
+  private BluetoothManager mBluetoothManager;
+  private List<BluetoothDevice> mLastBluetoothDevices;
+
+  private HIDDeviceManager(final Context context) {
+    mContext = context;
+
+    HIDDeviceRegisterCallback();
+
+    mSharedPreferences = mContext.getSharedPreferences("hidapi", Context.MODE_PRIVATE);
+    mIsChromebook = mContext.getPackageManager().hasSystemFeature("org.chromium.arc.device_management");
+
+//        if (shouldClear) {
+//            SharedPreferences.Editor spedit = mSharedPreferences.edit();
+//            spedit.clear();
+//            spedit.commit();
+//        }
+//        else
+    {
+      mNextDeviceId = mSharedPreferences.getInt("next_device_id", 0);
+    }
+  }
+
+  public static HIDDeviceManager acquire(Context context) {
+    if (sManagerRefCount == 0) {
+      sManager = new HIDDeviceManager(context);
+    }
+    ++sManagerRefCount;
+    return sManager;
+  }
+
+  public static void release(HIDDeviceManager manager) {
+    if (manager == sManager) {
+      --sManagerRefCount;
+      if (sManagerRefCount == 0) {
+        sManager.close();
+        sManager = null;
+      }
+    }
+  }
+
+  public Context getContext() {
+    return mContext;
+  }
+
+  public int getDeviceIDForIdentifier(String identifier) {
+    SharedPreferences.Editor spedit = mSharedPreferences.edit();
+
+    int result = mSharedPreferences.getInt(identifier, 0);
+    if (result == 0) {
+      result = mNextDeviceId++;
+      spedit.putInt("next_device_id", mNextDeviceId);
+    }
+
+    spedit.putInt(identifier, result);
+    spedit.commit();
+    return result;
+  }
+
+  private void initializeUSB() {
+    mUsbManager = (UsbManager) mContext.getSystemService(Context.USB_SERVICE);
+    if (mUsbManager == null) {
+      return;
+    }
+
+        /*
+        // Logging
+        for (UsbDevice device : mUsbManager.getDeviceList().values()) {
+            Log.i(TAG,"Path: " + device.getDeviceName());
+            Log.i(TAG,"Manufacturer: " + device.getManufacturerName());
+            Log.i(TAG,"Product: " + device.getProductName());
+            Log.i(TAG,"ID: " + device.getDeviceId());
+            Log.i(TAG,"Class: " + device.getDeviceClass());
+            Log.i(TAG,"Protocol: " + device.getDeviceProtocol());
+            Log.i(TAG,"Vendor ID " + device.getVendorId());
+            Log.i(TAG,"Product ID: " + device.getProductId());
+            Log.i(TAG,"Interface count: " + device.getInterfaceCount());
+            Log.i(TAG,"---------------------------------------");
+
+            // Get interface details
+            for (int index = 0; index < device.getInterfaceCount(); index++) {
+                UsbInterface mUsbInterface = device.getInterface(index);
+                Log.i(TAG,"  *****     *****");
+                Log.i(TAG,"  Interface index: " + index);
+                Log.i(TAG,"  Interface ID: " + mUsbInterface.getId());
+                Log.i(TAG,"  Interface class: " + mUsbInterface.getInterfaceClass());
+                Log.i(TAG,"  Interface subclass: " + mUsbInterface.getInterfaceSubclass());
+                Log.i(TAG,"  Interface protocol: " + mUsbInterface.getInterfaceProtocol());
+                Log.i(TAG,"  Endpoint count: " + mUsbInterface.getEndpointCount());
+
+                // Get endpoint details
+                for (int epi = 0; epi < mUsbInterface.getEndpointCount(); epi++)
+                {
+                    UsbEndpoint mEndpoint = mUsbInterface.getEndpoint(epi);
+                    Log.i(TAG,"    ++++   ++++   ++++");
+                    Log.i(TAG,"    Endpoint index: " + epi);
+                    Log.i(TAG,"    Attributes: " + mEndpoint.getAttributes());
+                    Log.i(TAG,"    Direction: " + mEndpoint.getDirection());
+                    Log.i(TAG,"    Number: " + mEndpoint.getEndpointNumber());
+                    Log.i(TAG,"    Interval: " + mEndpoint.getInterval());
+                    Log.i(TAG,"    Packet size: " + mEndpoint.getMaxPacketSize());
+                    Log.i(TAG,"    Type: " + mEndpoint.getType());
+                }
+            }
+        }
+        Log.i(TAG," No more devices connected.");
+        */
+
+    // Register for USB broadcasts and permission completions
+    IntentFilter filter = new IntentFilter();
+    filter.addAction(UsbManager.ACTION_USB_DEVICE_ATTACHED);
+    filter.addAction(UsbManager.ACTION_USB_DEVICE_DETACHED);
+    filter.addAction(HIDDeviceManager.ACTION_USB_PERMISSION);
+    mContext.registerReceiver(mUsbBroadcast, filter);
+
+    for (UsbDevice usbDevice : mUsbManager.getDeviceList().values()) {
+      handleUsbDeviceAttached(usbDevice);
+    }
+  }
+
+  UsbManager getUSBManager() {
+    return mUsbManager;
+  }
+
+  private void shutdownUSB() {
+    try {
+      mContext.unregisterReceiver(mUsbBroadcast);
+    } catch (Exception e) {
+      // We may not have registered, that's okay
+    }
+  }
+
+  private boolean isHIDDeviceInterface(UsbDevice usbDevice, UsbInterface usbInterface) {
+    if (usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_HID) {
+      return true;
+    }
+    return isXbox360Controller(usbDevice, usbInterface) || isXboxOneController(usbDevice, usbInterface);
+  }
+
+  private boolean isXbox360Controller(UsbDevice usbDevice, UsbInterface usbInterface) {
+    final int XB360_IFACE_SUBCLASS = 93;
+    final int XB360_IFACE_PROTOCOL = 1; // Wired
+    final int XB360W_IFACE_PROTOCOL = 129; // Wireless
+    final int[] SUPPORTED_VENDORS = {
+      0x0079, // GPD Win 2
+      0x044f, // Thrustmaster
+      0x045e, // Microsoft
+      0x046d, // Logitech
+      0x056e, // Elecom
+      0x06a3, // Saitek
+      0x0738, // Mad Catz
+      0x07ff, // Mad Catz
+      0x0e6f, // PDP
+      0x0f0d, // Hori
+      0x1038, // SteelSeries
+      0x11c9, // Nacon
+      0x12ab, // Unknown
+      0x1430, // RedOctane
+      0x146b, // BigBen
+      0x1532, // Razer Sabertooth
+      0x15e4, // Numark
+      0x162e, // Joytech
+      0x1689, // Razer Onza
+      0x1949, // Lab126, Inc.
+      0x1bad, // Harmonix
+      0x20d6, // PowerA
+      0x24c6, // PowerA
+      0x2c22, // Qanba
+      0x2dc8, // 8BitDo
+      0x9886, // ASTRO Gaming
+    };
+
+    if (usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_VENDOR_SPEC &&
+      usbInterface.getInterfaceSubclass() == XB360_IFACE_SUBCLASS &&
+      (usbInterface.getInterfaceProtocol() == XB360_IFACE_PROTOCOL ||
+        usbInterface.getInterfaceProtocol() == XB360W_IFACE_PROTOCOL)) {
+      int vendor_id = usbDevice.getVendorId();
+      for (int supportedVid : SUPPORTED_VENDORS) {
+        if (vendor_id == supportedVid) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  private boolean isXboxOneController(UsbDevice usbDevice, UsbInterface usbInterface) {
+    final int XB1_IFACE_SUBCLASS = 71;
+    final int XB1_IFACE_PROTOCOL = 208;
+    final int[] SUPPORTED_VENDORS = {
+      0x03f0, // HP
+      0x044f, // Thrustmaster
+      0x045e, // Microsoft
+      0x0738, // Mad Catz
+      0x0b05, // ASUS
+      0x0e6f, // PDP
+      0x0f0d, // Hori
+      0x10f5, // Turtle Beach
+      0x1532, // Razer Wildcat
+      0x20d6, // PowerA
+      0x24c6, // PowerA
+      0x2dc8, // 8BitDo
+      0x2e24, // Hyperkin
+      0x3537, // GameSir
+    };
+
+    if (usbInterface.getId() == 0 &&
+      usbInterface.getInterfaceClass() == UsbConstants.USB_CLASS_VENDOR_SPEC &&
+      usbInterface.getInterfaceSubclass() == XB1_IFACE_SUBCLASS &&
+      usbInterface.getInterfaceProtocol() == XB1_IFACE_PROTOCOL) {
+      int vendor_id = usbDevice.getVendorId();
+      for (int supportedVid : SUPPORTED_VENDORS) {
+        if (vendor_id == supportedVid) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  private void handleUsbDeviceAttached(UsbDevice usbDevice) {
+    connectHIDDeviceUSB(usbDevice);
+  }
+
+  private void handleUsbDeviceDetached(UsbDevice usbDevice) {
+    List<Integer> devices = new ArrayList<Integer>();
+    for (HIDDevice device : mDevicesById.values()) {
+      if (usbDevice.equals(device.getDevice())) {
+        devices.add(device.getId());
+      }
+    }
+    for (int id : devices) {
+      HIDDevice device = mDevicesById.get(id);
+      mDevicesById.remove(id);
+      device.shutdown();
+      HIDDeviceDisconnected(id);
+    }
+  }
+
+  private void handleUsbDevicePermission(UsbDevice usbDevice, boolean permission_granted) {
+    for (HIDDevice device : mDevicesById.values()) {
+      if (usbDevice.equals(device.getDevice())) {
+        boolean opened = false;
+        if (permission_granted) {
+          opened = device.open();
+        }
+        HIDDeviceOpenResult(device.getId(), opened);
+      }
+    }
+  }
+
+  private void connectHIDDeviceUSB(UsbDevice usbDevice) {
+    synchronized (this) {
+      int interface_mask = 0;
+      for (int interface_index = 0; interface_index < usbDevice.getInterfaceCount(); interface_index++) {
+        UsbInterface usbInterface = usbDevice.getInterface(interface_index);
+        if (isHIDDeviceInterface(usbDevice, usbInterface)) {
+          // Check to see if we've already added this interface
+          // This happens with the Xbox Series X controller which has a duplicate interface 0, which is inactive
+          int interface_id = usbInterface.getId();
+          if ((interface_mask & (1 << interface_id)) != 0) {
+            continue;
+          }
+          interface_mask |= (1 << interface_id);
+
+          HIDDeviceUSB device = new HIDDeviceUSB(this, usbDevice, interface_index);
+          int id = device.getId();
+          mDevicesById.put(id, device);
+          HIDDeviceConnected(id, device.getIdentifier(), device.getVendorId(), device.getProductId(), device.getSerialNumber(), device.getVersion(), device.getManufacturerName(), device.getProductName(), usbInterface.getId(), usbInterface.getInterfaceClass(), usbInterface.getInterfaceSubclass(), usbInterface.getInterfaceProtocol());
+        }
+      }
+    }
+  }
+
+  private void initializeBluetooth() {
+    Log.d(TAG, "Initializing Bluetooth");
+
+    if (Build.VERSION.SDK_INT >= 31 /* Android 12  */ &&
+      mContext.getPackageManager().checkPermission(android.Manifest.permission.BLUETOOTH_CONNECT, mContext.getPackageName()) != PackageManager.PERMISSION_GRANTED) {
+      Log.d(TAG, "Couldn't initialize Bluetooth, missing android.permission.BLUETOOTH_CONNECT");
+      return;
+    }
+
+    if (Build.VERSION.SDK_INT <= 30 /* Android 11.0 (R) */ &&
+      mContext.getPackageManager().checkPermission(android.Manifest.permission.BLUETOOTH, mContext.getPackageName()) != PackageManager.PERMISSION_GRANTED) {
+      Log.d(TAG, "Couldn't initialize Bluetooth, missing android.permission.BLUETOOTH");
+      return;
+    }
+
+    if (!mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE) || (Build.VERSION.SDK_INT < 18 /* Android 4.3 (JELLY_BEAN_MR2) */)) {
+      Log.d(TAG, "Couldn't initialize Bluetooth, this version of Android does not support Bluetooth LE");
+      return;
+    }
+
+    // Find bonded bluetooth controllers and create SteamControllers for them
+    mBluetoothManager = (BluetoothManager) mContext.getSystemService(Context.BLUETOOTH_SERVICE);
+    if (mBluetoothManager == null) {
+      // This device doesn't support Bluetooth.
+      return;
+    }
+
+    BluetoothAdapter btAdapter = mBluetoothManager.getAdapter();
+    if (btAdapter == null) {
+      // This device has Bluetooth support in the codebase, but has no available adapters.
+      return;
+    }
+
+    // Get our bonded devices.
+    for (BluetoothDevice device : btAdapter.getBondedDevices()) {
+
+      Log.d(TAG, "Bluetooth device available: " + device);
+      if (isSteamController(device)) {
+        connectBluetoothDevice(device);
+      }
+
+    }
+
+    // NOTE: These don't work on Chromebooks, to my undying dismay.
+    IntentFilter filter = new IntentFilter();
+    filter.addAction(BluetoothDevice.ACTION_ACL_CONNECTED);
+    filter.addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED);
+    mContext.registerReceiver(mBluetoothBroadcast, filter);
+
+    if (mIsChromebook) {
+      mHandler = new Handler(Looper.getMainLooper());
+      mLastBluetoothDevices = new ArrayList<BluetoothDevice>();
+
+      // final HIDDeviceManager finalThis = this;
+      // mHandler.postDelayed(new Runnable() {
+      //     @Override
+      //     public void run() {
+      //         finalThis.chromebookConnectionHandler();
+      //     }
+      // }, 5000);
+    }
+  }
+
+  private void shutdownBluetooth() {
+    try {
+      mContext.unregisterReceiver(mBluetoothBroadcast);
+    } catch (Exception e) {
+      // We may not have registered, that's okay
+    }
+  }
+
+  // Chromebooks do not pass along ACTION_ACL_CONNECTED / ACTION_ACL_DISCONNECTED properly.
+  // This function provides a sort of dummy version of that, watching for changes in the
+  // connected devices and attempting to add controllers as things change.
+  public void chromebookConnectionHandler() {
+    if (!mIsChromebook) {
+      return;
+    }
+
+    ArrayList<BluetoothDevice> disconnected = new ArrayList<BluetoothDevice>();
+    ArrayList<BluetoothDevice> connected = new ArrayList<BluetoothDevice>();
+
+    List<BluetoothDevice> currentConnected = mBluetoothManager.getConnectedDevices(BluetoothProfile.GATT);
+
+    for (BluetoothDevice bluetoothDevice : currentConnected) {
+      if (!mLastBluetoothDevices.contains(bluetoothDevice)) {
+        connected.add(bluetoothDevice);
+      }
+    }
+    for (BluetoothDevice bluetoothDevice : mLastBluetoothDevices) {
+      if (!currentConnected.contains(bluetoothDevice)) {
+        disconnected.add(bluetoothDevice);
+      }
+    }
+
+    mLastBluetoothDevices = currentConnected;
+
+    for (BluetoothDevice bluetoothDevice : disconnected) {
+      disconnectBluetoothDevice(bluetoothDevice);
+    }
+    for (BluetoothDevice bluetoothDevice : connected) {
+      connectBluetoothDevice(bluetoothDevice);
+    }
+
+    final HIDDeviceManager finalThis = this;
+    mHandler.postDelayed(new Runnable() {
+      @Override
+      public void run() {
+        finalThis.chromebookConnectionHandler();
+      }
+    }, 10000);
+  }
+
+  public boolean connectBluetoothDevice(BluetoothDevice bluetoothDevice) {
+    Log.v(TAG, "connectBluetoothDevice device=" + bluetoothDevice);
+    synchronized (this) {
+      if (mBluetoothDevices.containsKey(bluetoothDevice)) {
+        Log.v(TAG, "Steam controller with address " + bluetoothDevice + " already exists, attempting reconnect");
+
+        HIDDeviceBLESteamController device = mBluetoothDevices.get(bluetoothDevice);
+        device.reconnect();
+
+        return false;
+      }
+      HIDDeviceBLESteamController device = new HIDDeviceBLESteamController(this, bluetoothDevice);
+      int id = device.getId();
+      mBluetoothDevices.put(bluetoothDevice, device);
+      mDevicesById.put(id, device);
+
+      // The Steam Controller will mark itself connected once initialization is complete
+    }
+    return true;
+  }
+
+  public void disconnectBluetoothDevice(BluetoothDevice bluetoothDevice) {
+    synchronized (this) {
+      HIDDeviceBLESteamController device = mBluetoothDevices.get(bluetoothDevice);
+      if (device == null)
+        return;
+
+      int id = device.getId();
+      mBluetoothDevices.remove(bluetoothDevice);
+      mDevicesById.remove(id);
+      device.shutdown();
+      HIDDeviceDisconnected(id);
+    }
+  }
+
+  public boolean isSteamController(BluetoothDevice bluetoothDevice) {
+    // Sanity check.  If you pass in a null device, by definition it is never a Steam Controller.
+    if (bluetoothDevice == null) {
+      return false;
+    }
+
+    // If the device has no local name, we really don't want to try an equality check against it.
+    if (bluetoothDevice.getName() == null) {
+      return false;
+    }
+
+    return bluetoothDevice.getName().equals("SteamController") && ((bluetoothDevice.getType() & BluetoothDevice.DEVICE_TYPE_LE) != 0);
+  }
+
+  private void close() {
+    shutdownUSB();
+    shutdownBluetooth();
+    synchronized (this) {
+      for (HIDDevice device : mDevicesById.values()) {
+        device.shutdown();
+      }
+      mDevicesById.clear();
+      mBluetoothDevices.clear();
+      HIDDeviceReleaseCallback();
+    }
+  }
+
+  public void setFrozen(boolean frozen) {
+    synchronized (this) {
+      for (HIDDevice device : mDevicesById.values()) {
+        device.setFrozen(frozen);
+      }
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private HIDDevice getDevice(int id) {
+    synchronized (this) {
+      HIDDevice result = mDevicesById.get(id);
+      if (result == null) {
+        Log.v(TAG, "No device for id: " + id);
+        Log.v(TAG, "Available devices: " + mDevicesById.keySet());
+      }
+      return result;
+    }
+  }
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+  ////////// JNI interface functions
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  public boolean initialize(boolean usb, boolean bluetooth) {
+    Log.v(TAG, "initialize(" + usb + ", " + bluetooth + ")");
+
+    if (usb) {
+      initializeUSB();
+    }
+    if (bluetooth) {
+      initializeBluetooth();
+    }
+    return true;
+  }
+
+  public boolean openDevice(int deviceID) {
+    Log.v(TAG, "openDevice deviceID=" + deviceID);
+    HIDDevice device = getDevice(deviceID);
+    if (device == null) {
+      HIDDeviceDisconnected(deviceID);
+      return false;
+    }
+
+    // Look to see if this is a USB device and we have permission to access it
+    UsbDevice usbDevice = device.getDevice();
+    if (usbDevice != null && !mUsbManager.hasPermission(usbDevice)) {
+      HIDDeviceOpenPending(deviceID);
+      try {
+        final int FLAG_MUTABLE = 0x02000000; // PendingIntent.FLAG_MUTABLE, but don't require SDK 31
+        int flags;
+        if (Build.VERSION.SDK_INT >= 31 /* Android 12.0 (S) */) {
+          flags = FLAG_MUTABLE;
+        } else {
+          flags = 0;
+        }
+        if (Build.VERSION.SDK_INT >= 33 /* Android 14.0 (U) */) {
+          Intent intent = new Intent(HIDDeviceManager.ACTION_USB_PERMISSION);
+          intent.setPackage(mContext.getPackageName());
+          mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(mContext, 0, intent, flags));
+        } else {
+          mUsbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(mContext, 0, new Intent(HIDDeviceManager.ACTION_USB_PERMISSION), flags));
+        }
+      } catch (Exception e) {
+        Log.v(TAG, "Couldn't request permission for USB device " + usbDevice);
+        HIDDeviceOpenResult(deviceID, false);
+      }
+      return false;
+    }
+
+    try {
+      return device.open();
+    } catch (Exception e) {
+      Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
+    }
+    return false;
+  }
+
+  public int sendOutputReport(int deviceID, byte[] report) {
+    try {
+      //Log.v(TAG, "sendOutputReport deviceID=" + deviceID + " length=" + report.length);
+      HIDDevice device;
+      device = getDevice(deviceID);
+      if (device == null) {
+        HIDDeviceDisconnected(deviceID);
+        return -1;
+      }
+
+      return device.sendOutputReport(report);
+    } catch (Exception e) {
+      Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
+    }
+    return -1;
+  }
+
+  public int sendFeatureReport(int deviceID, byte[] report) {
+    try {
+      //Log.v(TAG, "sendFeatureReport deviceID=" + deviceID + " length=" + report.length);
+      HIDDevice device;
+      device = getDevice(deviceID);
+      if (device == null) {
+        HIDDeviceDisconnected(deviceID);
+        return -1;
+      }
+
+      return device.sendFeatureReport(report);
+    } catch (Exception e) {
+      Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
+    }
+    return -1;
+  }
+
+  public boolean getFeatureReport(int deviceID, byte[] report) {
+    try {
+      //Log.v(TAG, "getFeatureReport deviceID=" + deviceID);
+      HIDDevice device;
+      device = getDevice(deviceID);
+      if (device == null) {
+        HIDDeviceDisconnected(deviceID);
+        return false;
+      }
+
+      return device.getFeatureReport(report);
+    } catch (Exception e) {
+      Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
+    }
+    return false;
+  }
+
+  public void closeDevice(int deviceID) {
+    try {
+      Log.v(TAG, "closeDevice deviceID=" + deviceID);
+      HIDDevice device;
+      device = getDevice(deviceID);
+      if (device == null) {
+        HIDDeviceDisconnected(deviceID);
+        return;
+      }
+
+      device.close();
+    } catch (Exception e) {
+      Log.e(TAG, "Got exception: " + Log.getStackTraceString(e));
+    }
+  }
+
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+  /////////////// Native methods
+  //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+  private native void HIDDeviceRegisterCallback();
+
+  private native void HIDDeviceReleaseCallback();
+
+  native void HIDDeviceConnected(int deviceID, String identifier, int vendorId, int productId, String serial_number, int release_number, String manufacturer_string, String product_string, int interface_number, int interface_class, int interface_subclass, int interface_protocol);
+
+  native void HIDDeviceOpenPending(int deviceID);
+
+  native void HIDDeviceOpenResult(int deviceID, boolean opened);
+
+  native void HIDDeviceDisconnected(int deviceID);
+
+  native void HIDDeviceInputReport(int deviceID, byte[] report);
+
+  native void HIDDeviceFeatureReport(int deviceID, byte[] report);
+}
diff --git a/android/src/main/java/org/libsdl/app/HIDDeviceUSB.java b/android/src/main/java/org/libsdl/app/HIDDeviceUSB.java
new file mode 100644
index 000000000..c82a0c632
--- /dev/null
+++ b/android/src/main/java/org/libsdl/app/HIDDeviceUSB.java
@@ -0,0 +1,310 @@
+package org.libsdl.app;
+
+import android.hardware.usb.UsbConstants;
+import android.hardware.usb.UsbDevice;
+import android.hardware.usb.UsbDeviceConnection;
+import android.hardware.usb.UsbEndpoint;
+import android.hardware.usb.UsbInterface;
+import android.os.Build;
+import android.util.Log;
+
+import java.util.Arrays;
+
+class HIDDeviceUSB implements HIDDevice {
+
+  private static final String TAG = "hidapi";
+
+  protected HIDDeviceManager mManager;
+  protected UsbDevice mDevice;
+  protected int mInterfaceIndex;
+  protected int mInterface;
+  protected int mDeviceId;
+  protected UsbDeviceConnection mConnection;
+  protected UsbEndpoint mInputEndpoint;
+  protected UsbEndpoint mOutputEndpoint;
+  protected InputThread mInputThread;
+  protected boolean mRunning;
+  protected boolean mFrozen;
+
+  public HIDDeviceUSB(HIDDeviceManager manager, UsbDevice usbDevice, int interface_index) {
+    mManager = manager;
+    mDevice = usbDevice;
+    mInterfaceIndex = interface_index;
+    mInterface = mDevice.getInterface(mInterfaceIndex).getId();
+    mDeviceId = manager.getDeviceIDForIdentifier(getIdentifier());
+    mRunning = false;
+  }
+
+  public String getIdentifier() {
+    return String.format("%s/%x/%x/%d", mDevice.getDeviceName(), mDevice.getVendorId(), mDevice.getProductId(), mInterfaceIndex);
+  }
+
+  @Override
+  public int getId() {
+    return mDeviceId;
+  }
+
+  @Override
+  public int getVendorId() {
+    return mDevice.getVendorId();
+  }
+
+  @Override
+  public int getProductId() {
+    return mDevice.getProductId();
+  }
+
+  @Override
+  public String getSerialNumber() {
+    String result = null;
+    if (Build.VERSION.SDK_INT >= 21 /* Android 5.0 (LOLLIPOP) */) {
+      try {
+        result = mDevice.getSerialNumber();
+      } catch (SecurityException exception) {
+        //Log.w(TAG, "App permissions mean we cannot get serial number for device " + getDeviceName() + " message: " + exception.getMessage());
+      }
+    }
+    if (result == null) {
+      result = "";
+    }
+    return result;
+  }
+
+  @Override
+  public int getVersion() {
+    return 0;
+  }
+
+  @Override
+  public String getManufacturerName() {
+    String result = null;
+    if (Build.VERSION.SDK_INT >= 21 /* Android 5.0 (LOLLIPOP) */) {
+      result = mDevice.getManufacturerName();
+    }
+    if (result == null) {
+      result = String.format("%x", getVendorId());
+    }
+    return result;
+  }
+
+  @Override
+  public String getProductName() {
+    String result = null;
+    if (Build.VERSION.SDK_INT >= 21 /* Android 5.0 (LOLLIPOP) */) {
+      result = mDevice.getProductName();
+    }
+    if (result == null) {
+      result = String.format("%x", getProductId());
+    }
+    return result;
+  }
+
+  @Override
+  public UsbDevice getDevice() {
+    return mDevice;
+  }
+
+  public String getDeviceName() {
+    return getManufacturerName() + " " + getProductName() + "(0x" + String.format("%x", getVendorId()) + "/0x" + String.format("%x", getProductId()) + ")";
+  }
+
+  @Override
+  public boolean open() {
+    mConnection = mManager.getUSBManager().openDevice(mDevice);
+    if (mConnection == null) {
+      Log.w(TAG, "Unable to open USB device " + getDeviceName());
+      return false;
+    }
+
+    // Force claim our interface
+    UsbInterface iface = mDevice.getInterface(mInterfaceIndex);
+    if (!mConnection.claimInterface(iface, true)) {
+      Log.w(TAG, "Failed to claim interfaces on USB device " + getDeviceName());
+      close();
+      return false;
+    }
+
+    // Find the endpoints
+    for (int j = 0; j < iface.getEndpointCount(); j++) {
+      UsbEndpoint endpt = iface.getEndpoint(j);
+      switch (endpt.getDirection()) {
+        case UsbConstants.USB_DIR_IN:
+          if (mInputEndpoint == null) {
+            mInputEndpoint = endpt;
+          }
+          break;
+        case UsbConstants.USB_DIR_OUT:
+          if (mOutputEndpoint == null) {
+            mOutputEndpoint = endpt;
+          }
+          break;
+      }
+    }
+
+    // Make sure the required endpoints were present
+    if (mInputEndpoint == null || mOutputEndpoint == null) {
+      Log.w(TAG, "Missing required endpoint on USB device " + getDeviceName());
+      close();
+      return false;
+    }
+
+    // Start listening for input
+    mRunning = true;
+    mInputThread = new InputThread();
+    mInputThread.start();
+
+    return true;
+  }
+
+  @Override
+  public int sendFeatureReport(byte[] report) {
+    int res = -1;
+    int offset = 0;
+    int length = report.length;
+    boolean skipped_report_id = false;
+    byte report_number = report[0];
+
+    if (report_number == 0x0) {
+      ++offset;
+      --length;
+      skipped_report_id = true;
+    }
+
+    res = mConnection.controlTransfer(
+      UsbConstants.USB_TYPE_CLASS | 0x01 /*RECIPIENT_INTERFACE*/ | UsbConstants.USB_DIR_OUT,
+      0x09/*HID set_report*/,
+      (3/*HID feature*/ << 8) | report_number,
+      mInterface,
+      report, offset, length,
+      1000/*timeout millis*/);
+
+    if (res < 0) {
+      Log.w(TAG, "sendFeatureReport() returned " + res + " on device " + getDeviceName());
+      return -1;
+    }
+
+    if (skipped_report_id) {
+      ++length;
+    }
+    return length;
+  }
+
+  @Override
+  public int sendOutputReport(byte[] report) {
+    int r = mConnection.bulkTransfer(mOutputEndpoint, report, report.length, 1000);
+    if (r != report.length) {
+      Log.w(TAG, "sendOutputReport() returned " + r + " on device " + getDeviceName());
+    }
+    return r;
+  }
+
+  @Override
+  public boolean getFeatureReport(byte[] report) {
+    int res = -1;
+    int offset = 0;
+    int length = report.length;
+    boolean skipped_report_id = false;
+    byte report_number = report[0];
+
+    if (report_number == 0x0) {
+            /* Offset the return buffer by 1, so that the report ID
+               will remain in byte 0. */
+      ++offset;
+      --length;
+      skipped_report_id = true;
+    }
+
+    res = mConnection.controlTransfer(
+      UsbConstants.USB_TYPE_CLASS | 0x01 /*RECIPIENT_INTERFACE*/ | UsbConstants.USB_DIR_IN,
+      0x01/*HID get_report*/,
+      (3/*HID feature*/ << 8) | report_number,
+      mInterface,
+      report, offset, length,
+      1000/*timeout millis*/);
+
+    if (res < 0) {
+      Log.w(TAG, "getFeatureReport() returned " + res + " on device " + getDeviceName());
+      return false;
+    }
+
+    if (skipped_report_id) {
+      ++res;
+      ++length;
+    }
+
+    byte[] data;
+    if (res == length) {
+      data = report;
+    } else {
+      data = Arrays.copyOfRange(report, 0, res);
+    }
+    mManager.HIDDeviceFeatureReport(mDeviceId, data);
+
+    return true;
+  }
+
+  @Override
+  public void close() {
+    mRunning = false;
+    if (mInputThread != null) {
+      while (mInputThread.isAlive()) {
+        mInputThread.interrupt();
+        try {
+          mInputThread.join();
+        } catch (InterruptedException e) {
+          // Keep trying until we're done
+        }
+      }
+      mInputThread = null;
+    }
+    if (mConnection != null) {
+      UsbInterface iface = mDevice.getInterface(mInterfaceIndex);
+      mConnection.releaseInterface(iface);
+      mConnection.close();
+      mConnection = null;
+    }
+  }
+
+  @Override
+  public void shutdown() {
+    close();
+    mManager = null;
+  }
+
+  @Override
+  public void setFrozen(boolean frozen) {
+    mFrozen = frozen;
+  }
+
+  protected class InputThread extends Thread {
+    @Override
+    public void run() {
+      int packetSize = mInputEndpoint.getMaxPacketSize();
+      byte[] packet = new byte[packetSize];
+      while (mRunning) {
+        int r;
+        try {
+          r = mConnection.bulkTransfer(mInputEndpoint, packet, packetSize, 1000);
+        } catch (Exception e) {
+          Log.v(TAG, "Exception in UsbDeviceConnection bulktransfer: " + e);
+          break;
+        }
+        if (r < 0) {
+          // Could be a timeout or an I/O error
+        }
+        if (r > 0) {
+          byte[] data;
+          if (r == packetSize) {
+            data = packet;
+          } else {
+            data = Arrays.copyOfRange(packet, 0, r);
+          }
+
+          if (!mFrozen) {
+            mManager.HIDDeviceInputReport(mDeviceId, data);
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/android/src/main/java/org/libsdl/app/SDL.java b/android/src/main/java/org/libsdl/app/SDL.java
new file mode 100644
index 000000000..b2550c7ff
--- /dev/null
+++ b/android/src/main/java/org/libsdl/app/SDL.java
@@ -0,0 +1,86 @@
+package org.libsdl.app;
+
+import android.content.Context;
+
+import java.lang.reflect.Method;
+
+/**
+ * SDL library initialization
+ */
+public class SDL {
+
+  protected static Context mContext;
+
+  // This function should be called first and sets up the native code
+  // so it can call into the Java classes
+  public static void setupJNI() {
+    SDLActivity.nativeSetupJNI();
+    SDLAudioManager.nativeSetupJNI();
+    SDLControllerManager.nativeSetupJNI();
+  }
+
+  // This function should be called each time the activity is started
+  public static void initialize() {
+    setContext(null);
+
+    SDLActivity.initialize();
+    SDLAudioManager.initialize();
+    SDLControllerManager.initialize();
+  }
+
+  public static Context getContext() {
+    return mContext;
+  }
+
+  // This function stores the current activity (SDL or not)
+  public static void setContext(Context context) {
+    SDLAudioManager.setContext(context);
+    mContext = context;
+  }
+
+  public static void loadLibrary(String libraryName) throws UnsatisfiedLinkError, SecurityException, NullPointerException {
+    loadLibrary(libraryName, mContext);
+  }
+
+  public static void loadLibrary(String libraryName, Context context) throws UnsatisfiedLinkError, SecurityException, NullPointerException {
+
+    if (libraryName == null) {
+      throw new NullPointerException("No library name provided.");
+    }
+
+    try {
+      // Let's see if we have ReLinker available in the project.  This is necessary for
+      // some projects that have huge numbers of local libraries bundled, and thus may
+      // trip a bug in Android's native library loader which ReLinker works around.  (If
+      // loadLibrary works properly, ReLinker will simply use the normal Android method
+      // internally.)
+      //
+      // To use ReLinker, just add it as a dependency.  For more information, see
+      // https://github.com/KeepSafe/ReLinker for ReLinker's repository.
+      //
+      Class<?> relinkClass = context.getClassLoader().loadClass("com.getkeepsafe.relinker.ReLinker");
+      Class<?> relinkListenerClass = context.getClassLoader().loadClass("com.getkeepsafe.relinker.ReLinker$LoadListener");
+      Class<?> contextClass = context.getClassLoader().loadClass("android.content.Context");
+      Class<?> stringClass = context.getClassLoader().loadClass("java.lang.String");
+
+      // Get a 'force' instance of the ReLinker, so we can ensure libraries are reinstalled if
+      // they've changed during updates.
+      Method forceMethod = relinkClass.getDeclaredMethod("force");
+      Object relinkInstance = forceMethod.invoke(null);
+      Class<?> relinkInstanceClass = relinkInstance.getClass();
+
+      // Actually load the library!
+      Method loadMethod = relinkInstanceClass.getDeclaredMethod("loadLibrary", contextClass, stringClass, stringClass, relinkListenerClass);
+      loadMethod.invoke(relinkInstance, context, libraryName, null, null);
+    } catch (final Throwable e) {
+      // Fall back
+      try {
+        System.loadLibrary(libraryName);
+      } catch (final UnsatisfiedLinkError ule) {
+        throw ule;
+      } catch (final SecurityException se) {
+        throw se;
+      }
+    }
+  }
+}
diff --git a/android/src/main/java/org/libsdl/app/SDLActivity.java b/android/src/main/java/org/libsdl/app/SDLActivity.java
new file mode 100644
index 000000000..e78e6d3a9
--- /dev/null
+++ b/android/src/main/java/org/libsdl/app/SDLActivity.java
@@ -0,0 +1,2127 @@
+package org.libsdl.app;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.UiModeManager;
+import android.content.ClipData;
+import android.content.ClipboardManager;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import android.content.res.Configuration;
+import android.graphics.Bitmap;
+import android.graphics.Color;
+import android.graphics.PorterDuff;
+import android.graphics.drawable.Drawable;
+import android.hardware.Sensor;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Message;
+import android.text.Editable;
+import android.text.InputType;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.util.SparseArray;
+import android.view.Display;
+import android.view.Gravity;
+import android.view.InputDevice;
+import android.view.KeyEvent;
+import android.view.PointerIcon;
+import android.view.Surface;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.Window;
+import android.view.WindowManager;
+import android.view.inputmethod.BaseInputConnection;
+import android.view.inputmethod.EditorInfo;
+import android.view.inputmethod.InputConnection;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import java.util.Hashtable;
+import java.util.Locale;
+
+
+/**
+ * SDL Activity
+ */
+public class SDLActivity extends Activity implements View.OnSystemUiVisibilityChangeListener {
+  public static final boolean mHasMultiWindow = (Build.VERSION.SDK_INT >= 24  /* Android 7.0 (N) */);
+  protected static final int SDL_ORIENTATION_UNKNOWN = 0;
+  protected static final int SDL_ORIENTATION_LANDSCAPE = 1;
+  protected static final int SDL_ORIENTATION_LANDSCAPE_FLIPPED = 2;
+/*
+    // Display InputType.SOURCE/CLASS of events and devices
+    //
+    // SDLActivity.debugSource(device.getSources(), "device[" + device.getName() + "]");
+    // SDLActivity.debugSource(event.getSource(), "event");
+    public static void debugSource(int sources, String prefix) {
+        int s = sources;
+        int s_copy = sources;
+        String cls = "";
+        String src = "";
+        int tst = 0;
+        int FLAG_TAINTED = 0x80000000;
+
+        if ((s & InputDevice.SOURCE_CLASS_BUTTON) != 0)     cls += " BUTTON";
+        if ((s & InputDevice.SOURCE_CLASS_JOYSTICK) != 0)   cls += " JOYSTICK";
+        if ((s & InputDevice.SOURCE_CLASS_POINTER) != 0)    cls += " POINTER";
+        if ((s & InputDevice.SOURCE_CLASS_POSITION) != 0)   cls += " POSITION";
+        if ((s & InputDevice.SOURCE_CLASS_TRACKBALL) != 0)  cls += " TRACKBALL";
+
+
+        int s2 = s_copy & ~InputDevice.SOURCE_ANY; // keep class bits
+        s2 &= ~(  InputDevice.SOURCE_CLASS_BUTTON
+                | InputDevice.SOURCE_CLASS_JOYSTICK
+                | InputDevice.SOURCE_CLASS_POINTER
+                | InputDevice.SOURCE_CLASS_POSITION
+                | InputDevice.SOURCE_CLASS_TRACKBALL);
+
+        if (s2 != 0) cls += "Some_Unknown";
+
+        s2 = s_copy & InputDevice.SOURCE_ANY; // keep source only, no class;
+
+        if (Build.VERSION.SDK_INT >= 23) {
+            tst = InputDevice.SOURCE_BLUETOOTH_STYLUS;
+            if ((s & tst) == tst) src += " BLUETOOTH_STYLUS";
+            s2 &= ~tst;
+        }
+
+        tst = InputDevice.SOURCE_DPAD;
+        if ((s & tst) == tst) src += " DPAD";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_GAMEPAD;
+        if ((s & tst) == tst) src += " GAMEPAD";
+        s2 &= ~tst;
+
+        if (Build.VERSION.SDK_INT >= 21) {
+            tst = InputDevice.SOURCE_HDMI;
+            if ((s & tst) == tst) src += " HDMI";
+            s2 &= ~tst;
+        }
+
+        tst = InputDevice.SOURCE_JOYSTICK;
+        if ((s & tst) == tst) src += " JOYSTICK";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_KEYBOARD;
+        if ((s & tst) == tst) src += " KEYBOARD";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_MOUSE;
+        if ((s & tst) == tst) src += " MOUSE";
+        s2 &= ~tst;
+
+        if (Build.VERSION.SDK_INT >= 26) {
+            tst = InputDevice.SOURCE_MOUSE_RELATIVE;
+            if ((s & tst) == tst) src += " MOUSE_RELATIVE";
+            s2 &= ~tst;
+
+            tst = InputDevice.SOURCE_ROTARY_ENCODER;
+            if ((s & tst) == tst) src += " ROTARY_ENCODER";
+            s2 &= ~tst;
+        }
+        tst = InputDevice.SOURCE_STYLUS;
+        if ((s & tst) == tst) src += " STYLUS";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_TOUCHPAD;
+        if ((s & tst) == tst) src += " TOUCHPAD";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_TOUCHSCREEN;
+        if ((s & tst) == tst) src += " TOUCHSCREEN";
+        s2 &= ~tst;
+
+        if (Build.VERSION.SDK_INT >= 18) {
+            tst = InputDevice.SOURCE_TOUCH_NAVIGATION;
+            if ((s & tst) == tst) src += " TOUCH_NAVIGATION";
+            s2 &= ~tst;
+        }
+
+        tst = InputDevice.SOURCE_TRACKBALL;
+        if ((s & tst) == tst) src += " TRACKBALL";
+        s2 &= ~tst;
+
+        tst = InputDevice.SOURCE_ANY;
+        if ((s & tst) == tst) src += " ANY";
+        s2 &= ~tst;
+
+        if (s == FLAG_TAINTED) src += " FLAG_TAINTED";
+        s2 &= ~FLAG_TAINTED;
+
+        if (s2 != 0) src += " Some_Unknown";
+
+        Log.v(TAG, prefix + "int=" + s_copy + " CLASS={" + cls + " } source(s):" + src);
+    }
+*/
+  protected static final int SDL_ORIENTATION_PORTRAIT = 3;
+  protected static final int SDL_ORIENTATION_PORTRAIT_FLIPPED = 4;
+  protected static final int COMMAND_USER = 0x8000;
+  // Messages from the SDLMain thread
+  static final int COMMAND_CHANGE_TITLE = 1;
+  static final int COMMAND_CHANGE_WINDOW_STYLE = 2;
+  static final int COMMAND_TEXTEDIT_HIDE = 3;
+  static final int COMMAND_SET_KEEP_SCREEN_ON = 5;
+  private static final String TAG = "SDL";
+  private static final int SDL_MAJOR_VERSION = 2;
+  private static final int SDL_MINOR_VERSION = 30;
+  private static final int SDL_MICRO_VERSION = 8;
+  // Cursor types
+  // private static final int SDL_SYSTEM_CURSOR_NONE = -1;
+  private static final int SDL_SYSTEM_CURSOR_ARROW = 0;
+  private static final int SDL_SYSTEM_CURSOR_IBEAM = 1;
+  private static final int SDL_SYSTEM_CURSOR_WAIT = 2;
+  private static final int SDL_SYSTEM_CURSOR_CROSSHAIR = 3;
+  private static final int SDL_SYSTEM_CURSOR_WAITARROW = 4;
+  private static final int SDL_SYSTEM_CURSOR_SIZENWSE = 5;
+  private static final int SDL_SYSTEM_CURSOR_SIZENESW = 6;
+  private static final int SDL_SYSTEM_CURSOR_SIZEWE = 7;
+  private static final int SDL_SYSTEM_CURSOR_SIZENS = 8;
+  private static final int SDL_SYSTEM_CURSOR_SIZEALL = 9;
+  private static final int SDL_SYSTEM_CURSOR_NO = 10;
+  private static final int SDL_SYSTEM_CURSOR_HAND = 11;
+  public static boolean mIsResumedCalled, mHasFocus;
+  public static NativeState mNextNativeState;
+  public static NativeState mCurrentNativeState;
+  /**
+   * If shared libraries (e.g. SDL or the native application) could not be loaded.
+   */
+  public static boolean mBrokenLibraries = true;
+  protected static int mCurrentOrientation;
+  protected static Locale mCurrentLocale;
+  // Main components
+  protected static SDLActivity mSingleton;
+  protected static SDLSurface mSurface;
+  protected static DummyEdit mTextEdit;
+  protected static boolean mScreenKeyboardShown;
+  protected static ViewGroup mLayout;
+  protected static SDLClipboardHandler mClipboardHandler;
+  protected static Hashtable<Integer, PointerIcon> mCursors;
+  protected static int mLastCursorID;
+  protected static SDLGenericMotionListener_API12 mMotionListener;
+  protected static HIDDeviceManager mHIDDeviceManager;
+  // This is what SDL runs in. It invokes SDL_main(), eventually
+  protected static Thread mSDLThread;
+  protected static boolean mFullscreenModeActive;
+  /**
+   * Result of current messagebox. Also used for blocking the calling thread.
+   */
+  protected final int[] messageboxSelection = new int[1];
+  private final Runnable rehideSystemUi = new Runnable() {
+    @Override
+    public void run() {
+      if (Build.VERSION.SDK_INT >= 19 /* Android 4.4 (KITKAT) */) {
+        int flags = View.SYSTEM_UI_FLAG_FULLSCREEN |
+          View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
+          View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY |
+          View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
+          View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
+          View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.INVISIBLE;
+
+        SDLActivity.this.getWindow().getDecorView().setSystemUiVisibility(flags);
+      }
+    }
+  };
+  // Handler for the messages
+  Handler commandHandler = new SDLCommandHandler();
+
+  protected static SDLGenericMotionListener_API12 getMotionListener() {
+    if (mMotionListener == null) {
+      if (Build.VERSION.SDK_INT >= 26 /* Android 8.0 (O) */) {
+        mMotionListener = new SDLGenericMotionListener_API26();
+      } else if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+        mMotionListener = new SDLGenericMotionListener_API24();
+      } else {
+        mMotionListener = new SDLGenericMotionListener_API12();
+      }
+    }
+
+    return mMotionListener;
+  }
+
+  public static void initialize() {
+    // The static nature of the singleton and Android quirkyness force us to initialize everything here
+    // Otherwise, when exiting the app and returning to it, these variables *keep* their pre exit values
+    mSingleton = null;
+    mSurface = null;
+    mTextEdit = null;
+    mLayout = null;
+    mClipboardHandler = null;
+    mCursors = new Hashtable<Integer, PointerIcon>();
+    mLastCursorID = 0;
+    mSDLThread = null;
+    mIsResumedCalled = false;
+    mHasFocus = true;
+    mNextNativeState = NativeState.INIT;
+    mCurrentNativeState = NativeState.INIT;
+  }
+
+  public static int getCurrentOrientation() {
+    int result = SDL_ORIENTATION_UNKNOWN;
+
+    Activity activity = (Activity) getContext();
+    if (activity == null) {
+      return result;
+    }
+    Display display = activity.getWindowManager().getDefaultDisplay();
+
+    switch (display.getRotation()) {
+      case Surface.ROTATION_0:
+        result = SDL_ORIENTATION_PORTRAIT;
+        break;
+
+      case Surface.ROTATION_90:
+        result = SDL_ORIENTATION_LANDSCAPE;
+        break;
+
+      case Surface.ROTATION_180:
+        result = SDL_ORIENTATION_PORTRAIT_FLIPPED;
+        break;
+
+      case Surface.ROTATION_270:
+        result = SDL_ORIENTATION_LANDSCAPE_FLIPPED;
+        break;
+    }
+
+    return result;
+  }
+
+  // Called by JNI from SDL.
+  public static void manualBackButton() {
+    mSingleton.pressBackButton();
+  }
+
+  /* Transition to next state */
+  public static void handleNativeState() {
+
+    if (mNextNativeState == mCurrentNativeState) {
+      // Already in same state, discard.
+      return;
+    }
+
+    // Try a transition to init state
+    if (mNextNativeState == NativeState.INIT) {
+
+      mCurrentNativeState = mNextNativeState;
+      return;
+    }
+
+    // Try a transition to paused state
+    if (mNextNativeState == NativeState.PAUSED) {
+      if (mSDLThread != null) {
+        nativePause();
+      }
+      if (mSurface != null) {
+        mSurface.handlePause();
+      }
+      mCurrentNativeState = mNextNativeState;
+      return;
+    }
+
+    // Try a transition to resumed state
+    if (mNextNativeState == NativeState.RESUMED) {
+      if (mSurface.mIsSurfaceReady && mHasFocus && mIsResumedCalled) {
+        if (mSDLThread == null) {
+          // This is the entry point to the C app.
+          // Start up the C app thread and enable sensor input for the first time
+          // FIXME: Why aren't we enabling sensor input at start?
+
+          mSDLThread = new Thread(new SDLMain(), "SDLThread");
+          mSurface.enableSensor(Sensor.TYPE_ACCELEROMETER, true);
+          mSDLThread.start();
+
+          // No nativeResume(), don't signal Android_ResumeSem
+        } else {
+          nativeResume();
+        }
+        mSurface.handleResume();
+
+        mCurrentNativeState = mNextNativeState;
+      }
+    }
+  }
+
+  // C functions we call
+  public static native String nativeGetVersion();
+
+  public static native int nativeSetupJNI();
+
+  public static native int nativeRunMain(String library, String function, Object arguments);
+
+  public static native void nativeLowMemory();
+
+  public static native void nativeSendQuit();
+
+  public static native void nativeQuit();
+
+  public static native void nativePause();
+
+  public static native void nativeResume();
+
+  public static native void nativeFocusChanged(boolean hasFocus);
+
+  public static native void onNativeDropFile(String filename);
+
+  public static native void nativeSetScreenResolution(int surfaceWidth, int surfaceHeight, int deviceWidth, int deviceHeight, float rate);
+
+  public static native void onNativeResize();
+
+  public static native void onNativeKeyDown(int keycode);
+
+  public static native void onNativeKeyUp(int keycode);
+
+  public static native boolean onNativeSoftReturnKey();
+
+  public static native void onNativeKeyboardFocusLost();
+
+  public static native void onNativeMouse(int button, int action, float x, float y, boolean relative);
+
+  public static native void onNativeTouch(int touchDevId, int pointerFingerId,
+                                          int action, float x,
+                                          float y, float p);
+
+  public static native void onNativeAccel(float x, float y, float z);
+
+  public static native void onNativeClipboardChanged();
+
+  public static native void onNativeSurfaceCreated();
+
+  public static native void onNativeSurfaceChanged();
+
+  public static native void onNativeSurfaceDestroyed();
+
+  public static native String nativeGetHint(String name);
+
+  public static native boolean nativeGetHintBoolean(String name, boolean default_value);
+
+  public static native void nativeSetenv(String name, String value);
+
+  public static native void onNativeOrientationChanged(int orientation);
+
+  public static native void nativeAddTouch(int touchId, String name);
+
+  public static native void nativePermissionResult(int requestCode, boolean result);
+
+  public static native void onNativeLocaleChanged();
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean setActivityTitle(String title) {
+    // Called from SDLMain() thread and can't directly affect the view
+    return mSingleton.sendCommand(COMMAND_CHANGE_TITLE, title);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void setWindowStyle(boolean fullscreen) {
+    // Called from SDLMain() thread and can't directly affect the view
+    mSingleton.sendCommand(COMMAND_CHANGE_WINDOW_STYLE, fullscreen ? 1 : 0);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   * This is a static method for JNI convenience, it calls a non-static method
+   * so that is can be overridden
+   */
+  public static void setOrientation(int w, int h, boolean resizable, String hint) {
+    if (mSingleton != null) {
+      mSingleton.setOrientationBis(w, h, resizable, hint);
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void minimizeWindow() {
+
+    if (mSingleton == null) {
+      return;
+    }
+
+    Intent startMain = new Intent(Intent.ACTION_MAIN);
+    startMain.addCategory(Intent.CATEGORY_HOME);
+    startMain.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
+    mSingleton.startActivity(startMain);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean shouldMinimizeOnFocusLoss() {
+/*
+        if (Build.VERSION.SDK_INT >= 24) {
+            if (mSingleton == null) {
+                return true;
+            }
+
+            if (mSingleton.isInMultiWindowMode()) {
+                return false;
+            }
+
+            if (mSingleton.isInPictureInPictureMode()) {
+                return false;
+            }
+        }
+
+        return true;
+*/
+    return false;
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean isScreenKeyboardShown() {
+    if (mTextEdit == null) {
+      return false;
+    }
+
+    if (!mScreenKeyboardShown) {
+      return false;
+    }
+
+    InputMethodManager imm = (InputMethodManager) SDL.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+    return imm.isAcceptingText();
+
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean supportsRelativeMouse() {
+    // DeX mode in Samsung Experience 9.0 and earlier doesn't support relative mice properly under
+    // Android 7 APIs, and simply returns no data under Android 8 APIs.
+    //
+    // This is fixed in Samsung Experience 9.5, which corresponds to Android 8.1.0, and
+    // thus SDK version 27.  If we are in DeX mode and not API 27 or higher, as a result,
+    // we should stick to relative mode.
+    //
+    if (Build.VERSION.SDK_INT < 27 /* Android 8.1 (O_MR1) */ && isDeXMode()) {
+      return false;
+    }
+
+    return SDLActivity.getMotionListener().supportsRelativeMouse();
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean setRelativeMouseEnabled(boolean enabled) {
+    if (enabled && !supportsRelativeMouse()) {
+      return false;
+    }
+
+    return SDLActivity.getMotionListener().setRelativeMouseEnabled(enabled);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean sendMessage(int command, int param) {
+    if (mSingleton == null) {
+      return false;
+    }
+    return mSingleton.sendCommand(command, param);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static Context getContext() {
+    return SDL.getContext();
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean isAndroidTV() {
+    UiModeManager uiModeManager = (UiModeManager) getContext().getSystemService(UI_MODE_SERVICE);
+    if (uiModeManager.getCurrentModeType() == Configuration.UI_MODE_TYPE_TELEVISION) {
+      return true;
+    }
+    if (Build.MANUFACTURER.equals("MINIX") && Build.MODEL.equals("NEO-U1")) {
+      return true;
+    }
+    if (Build.MANUFACTURER.equals("Amlogic") && Build.MODEL.equals("X96-W")) {
+      return true;
+    }
+    return Build.MANUFACTURER.equals("Amlogic") && Build.MODEL.startsWith("TV");
+  }
+
+  public static double getDiagonal() {
+    DisplayMetrics metrics = new DisplayMetrics();
+    Activity activity = (Activity) getContext();
+    if (activity == null) {
+      return 0.0;
+    }
+    activity.getWindowManager().getDefaultDisplay().getMetrics(metrics);
+
+    double dWidthInches = metrics.widthPixels / (double) metrics.xdpi;
+    double dHeightInches = metrics.heightPixels / (double) metrics.ydpi;
+
+    return Math.sqrt((dWidthInches * dWidthInches) + (dHeightInches * dHeightInches));
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean isTablet() {
+    // If our diagonal size is seven inches or greater, we consider ourselves a tablet.
+    return (getDiagonal() >= 7.0);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean isChromebook() {
+    if (getContext() == null) {
+      return false;
+    }
+    return getContext().getPackageManager().hasSystemFeature("org.chromium.arc.device_management");
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean isDeXMode() {
+    if (Build.VERSION.SDK_INT < 24 /* Android 7.0 (N) */) {
+      return false;
+    }
+    try {
+      final Configuration config = getContext().getResources().getConfiguration();
+      final Class<?> configClass = config.getClass();
+      return configClass.getField("SEM_DESKTOP_MODE_ENABLED").getInt(configClass)
+        == configClass.getField("semDesktopModeEnabled").getInt(config);
+    } catch (Exception ignored) {
+      return false;
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static DisplayMetrics getDisplayDPI() {
+    return getContext().getResources().getDisplayMetrics();
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean getManifestEnvironmentVariables() {
+    try {
+      if (getContext() == null) {
+        return false;
+      }
+
+      ApplicationInfo applicationInfo = getContext().getPackageManager().getApplicationInfo(getContext().getPackageName(), PackageManager.GET_META_DATA);
+      Bundle bundle = applicationInfo.metaData;
+      if (bundle == null) {
+        return false;
+      }
+      String prefix = "SDL_ENV.";
+      final int trimLength = prefix.length();
+      for (String key : bundle.keySet()) {
+        if (key.startsWith(prefix)) {
+          String name = key.substring(trimLength);
+          String value = bundle.get(key).toString();
+          nativeSetenv(name, value);
+        }
+      }
+      /* environment variables set! */
+      return true;
+    } catch (Exception e) {
+      Log.v(TAG, "exception " + e);
+    }
+    return false;
+  }
+
+  // This method is called by SDLControllerManager's API 26 Generic Motion Handler.
+  public static View getContentView() {
+    return mLayout;
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean showTextInput(int x, int y, int w, int h) {
+    // Transfer the task to the main thread as a Runnable
+    return mSingleton.commandHandler.post(new ShowTextInputTask(x, y, w, h));
+  }
+
+  public static boolean isTextInputEvent(KeyEvent event) {
+
+    // Key pressed with Ctrl should be sent as SDL_KEYDOWN/SDL_KEYUP and not SDL_TEXTINPUT
+    if (event.isCtrlPressed()) {
+      return false;
+    }
+
+    return event.isPrintingKey() || event.getKeyCode() == KeyEvent.KEYCODE_SPACE;
+  }
+
+  public static boolean handleKeyEvent(View v, int keyCode, KeyEvent event, InputConnection ic) {
+    int deviceId = event.getDeviceId();
+    int source = event.getSource();
+
+    if (source == InputDevice.SOURCE_UNKNOWN) {
+      InputDevice device = InputDevice.getDevice(deviceId);
+      if (device != null) {
+        source = device.getSources();
+      }
+    }
+
+//        if (event.getAction() == KeyEvent.ACTION_DOWN) {
+//            Log.v("SDL", "key down: " + keyCode + ", deviceId = " + deviceId + ", source = " + source);
+//        } else if (event.getAction() == KeyEvent.ACTION_UP) {
+//            Log.v("SDL", "key up: " + keyCode + ", deviceId = " + deviceId + ", source = " + source);
+//        }
+
+    // Dispatch the different events depending on where they come from
+    // Some SOURCE_JOYSTICK, SOURCE_DPAD or SOURCE_GAMEPAD are also SOURCE_KEYBOARD
+    // So, we try to process them as JOYSTICK/DPAD/GAMEPAD events first, if that fails we try them as KEYBOARD
+    //
+    // Furthermore, it's possible a game controller has SOURCE_KEYBOARD and
+    // SOURCE_JOYSTICK, while its key events arrive from the keyboard source
+    // So, retrieve the device itself and check all of its sources
+    if (SDLControllerManager.isDeviceSDLJoystick(deviceId)) {
+      // Note that we process events with specific key codes here
+      if (event.getAction() == KeyEvent.ACTION_DOWN) {
+        if (SDLControllerManager.onNativePadDown(deviceId, keyCode) == 0) {
+          return true;
+        }
+      } else if (event.getAction() == KeyEvent.ACTION_UP) {
+        if (SDLControllerManager.onNativePadUp(deviceId, keyCode) == 0) {
+          return true;
+        }
+      }
+    }
+
+    if ((source & InputDevice.SOURCE_MOUSE) == InputDevice.SOURCE_MOUSE) {
+      // on some devices key events are sent for mouse BUTTON_BACK/FORWARD presses
+      // they are ignored here because sending them as mouse input to SDL is messy
+      if ((keyCode == KeyEvent.KEYCODE_BACK) || (keyCode == KeyEvent.KEYCODE_FORWARD)) {
+        switch (event.getAction()) {
+          case KeyEvent.ACTION_DOWN:
+          case KeyEvent.ACTION_UP:
+            // mark the event as handled or it will be handled by system
+            // handling KEYCODE_BACK by system will call onBackPressed()
+            return true;
+        }
+      }
+    }
+
+    if (event.getAction() == KeyEvent.ACTION_DOWN) {
+      if (isTextInputEvent(event)) {
+        if (ic != null) {
+          ic.commitText(String.valueOf((char) event.getUnicodeChar()), 1);
+        } else {
+          SDLInputConnection.nativeCommitText(String.valueOf((char) event.getUnicodeChar()), 1);
+        }
+      }
+      onNativeKeyDown(keyCode);
+      return true;
+    } else if (event.getAction() == KeyEvent.ACTION_UP) {
+      onNativeKeyUp(keyCode);
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static Surface getNativeSurface() {
+    if (SDLActivity.mSurface == null) {
+      return null;
+    }
+    return SDLActivity.mSurface.getNativeSurface();
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void initTouch() {
+    int[] ids = InputDevice.getDeviceIds();
+
+    for (int id : ids) {
+      InputDevice device = InputDevice.getDevice(id);
+      /* Allow SOURCE_TOUCHSCREEN and also Virtual InputDevices because they can send TOUCHSCREEN events */
+      if (device != null && ((device.getSources() & InputDevice.SOURCE_TOUCHSCREEN) == InputDevice.SOURCE_TOUCHSCREEN
+        || device.isVirtual())) {
+
+        int touchDevId = device.getId();
+        /*
+         * Prevent id to be -1, since it's used in SDL internal for synthetic events
+         * Appears when using Android emulator, eg:
+         *  adb shell input mouse tap 100 100
+         *  adb shell input touchscreen tap 100 100
+         */
+        if (touchDevId < 0) {
+          touchDevId -= 1;
+        }
+        nativeAddTouch(touchDevId, device.getName());
+      }
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean clipboardHasText() {
+    return mClipboardHandler.clipboardHasText();
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static String clipboardGetText() {
+    return mClipboardHandler.clipboardGetText();
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void clipboardSetText(String string) {
+    mClipboardHandler.clipboardSetText(string);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static int createCustomCursor(int[] colors, int width, int height, int hotSpotX, int hotSpotY) {
+    Bitmap bitmap = Bitmap.createBitmap(colors, width, height, Bitmap.Config.ARGB_8888);
+    ++mLastCursorID;
+
+    if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+      try {
+        mCursors.put(mLastCursorID, PointerIcon.create(bitmap, hotSpotX, hotSpotY));
+      } catch (Exception e) {
+        return 0;
+      }
+    } else {
+      return 0;
+    }
+    return mLastCursorID;
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void destroyCustomCursor(int cursorID) {
+    if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+      try {
+        mCursors.remove(cursorID);
+      } catch (Exception e) {
+      }
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean setCustomCursor(int cursorID) {
+
+    if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+      try {
+        mSurface.setPointerIcon(mCursors.get(cursorID));
+      } catch (Exception e) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static boolean setSystemCursor(int cursorID) {
+    int cursor_type = 0; //PointerIcon.TYPE_NULL;
+    switch (cursorID) {
+      case SDL_SYSTEM_CURSOR_ARROW:
+        cursor_type = 1000; //PointerIcon.TYPE_ARROW;
+        break;
+      case SDL_SYSTEM_CURSOR_IBEAM:
+        cursor_type = 1008; //PointerIcon.TYPE_TEXT;
+        break;
+      case SDL_SYSTEM_CURSOR_WAIT:
+        cursor_type = 1004; //PointerIcon.TYPE_WAIT;
+        break;
+      case SDL_SYSTEM_CURSOR_CROSSHAIR:
+        cursor_type = 1007; //PointerIcon.TYPE_CROSSHAIR;
+        break;
+      case SDL_SYSTEM_CURSOR_WAITARROW:
+        cursor_type = 1004; //PointerIcon.TYPE_WAIT;
+        break;
+      case SDL_SYSTEM_CURSOR_SIZENWSE:
+        cursor_type = 1017; //PointerIcon.TYPE_TOP_LEFT_DIAGONAL_DOUBLE_ARROW;
+        break;
+      case SDL_SYSTEM_CURSOR_SIZENESW:
+        cursor_type = 1016; //PointerIcon.TYPE_TOP_RIGHT_DIAGONAL_DOUBLE_ARROW;
+        break;
+      case SDL_SYSTEM_CURSOR_SIZEWE:
+        cursor_type = 1014; //PointerIcon.TYPE_HORIZONTAL_DOUBLE_ARROW;
+        break;
+      case SDL_SYSTEM_CURSOR_SIZENS:
+        cursor_type = 1015; //PointerIcon.TYPE_VERTICAL_DOUBLE_ARROW;
+        break;
+      case SDL_SYSTEM_CURSOR_SIZEALL:
+        cursor_type = 1020; //PointerIcon.TYPE_GRAB;
+        break;
+      case SDL_SYSTEM_CURSOR_NO:
+        cursor_type = 1012; //PointerIcon.TYPE_NO_DROP;
+        break;
+      case SDL_SYSTEM_CURSOR_HAND:
+        cursor_type = 1002; //PointerIcon.TYPE_HAND;
+        break;
+    }
+    if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+      try {
+        mSurface.setPointerIcon(PointerIcon.getSystemIcon(SDL.getContext(), cursor_type));
+      } catch (Exception e) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void requestPermission(String permission, int requestCode) {
+    if (Build.VERSION.SDK_INT < 23 /* Android 6.0 (M) */) {
+      nativePermissionResult(requestCode, true);
+      return;
+    }
+
+    Activity activity = (Activity) getContext();
+    if (activity.checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) {
+      activity.requestPermissions(new String[]{permission}, requestCode);
+    } else {
+      nativePermissionResult(requestCode, true);
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static int openURL(String url) {
+    try {
+      Intent i = new Intent(Intent.ACTION_VIEW);
+      i.setData(Uri.parse(url));
+
+      int flags = Intent.FLAG_ACTIVITY_NO_HISTORY | Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
+      if (Build.VERSION.SDK_INT >= 21 /* Android 5.0 (LOLLIPOP) */) {
+        flags |= Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
+      } else {
+        flags |= Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET;
+      }
+      i.addFlags(flags);
+
+      mSingleton.startActivity(i);
+    } catch (Exception ex) {
+      return -1;
+    }
+    return 0;
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static int showToast(String message, int duration, int gravity, int xOffset, int yOffset) {
+    if (null == mSingleton) {
+      return -1;
+    }
+
+    try {
+      class OneShotTask implements Runnable {
+        final String mMessage;
+        final int mDuration;
+        final int mGravity;
+        final int mXOffset;
+        final int mYOffset;
+
+        OneShotTask(String message, int duration, int gravity, int xOffset, int yOffset) {
+          mMessage = message;
+          mDuration = duration;
+          mGravity = gravity;
+          mXOffset = xOffset;
+          mYOffset = yOffset;
+        }
+
+        public void run() {
+          try {
+            Toast toast = Toast.makeText(mSingleton, mMessage, mDuration);
+            if (mGravity >= 0) {
+              toast.setGravity(mGravity, mXOffset, mYOffset);
+            }
+            toast.show();
+          } catch (Exception ex) {
+            Log.e(TAG, ex.getMessage());
+          }
+        }
+      }
+      mSingleton.runOnUiThread(new OneShotTask(message, duration, gravity, xOffset, yOffset));
+    } catch (Exception ex) {
+      return -1;
+    }
+    return 0;
+  }
+
+  /**
+   * This method returns the name of the shared object with the application entry point
+   * It can be overridden by derived classes.
+   */
+  protected String getMainSharedObject() {
+    String library;
+    String[] libraries = SDLActivity.mSingleton.getLibraries();
+    if (libraries.length > 0) {
+      library = "lib" + libraries[libraries.length - 1] + ".so";
+    } else {
+      library = "libmain.so";
+    }
+    return getContext().getApplicationInfo().nativeLibraryDir + "/" + library;
+  }
+
+  /**
+   * This method returns the name of the application entry point
+   * It can be overridden by derived classes.
+   */
+  protected String getMainFunction() {
+    return "SDL_main";
+  }
+
+  /**
+   * This method is called by SDL before loading the native shared libraries.
+   * It can be overridden to provide names of shared libraries to be loaded.
+   * The default implementation returns the defaults. It never returns null.
+   * An array returned by a new implementation must at least contain "SDL2".
+   * Also keep in mind that the order the libraries are loaded may matter.
+   *
+   * @return names of shared libraries to be loaded (e.g. "SDL2", "main").
+   */
+  protected String[] getLibraries() {
+    return new String[]{
+      "SDL2",
+      // "SDL2_image",
+      // "SDL2_mixer",
+      // "SDL2_net",
+      // "SDL2_ttf",
+      "main"
+    };
+  }
+
+  // Load the .so
+  public void loadLibraries() {
+    for (String lib : getLibraries()) {
+      SDL.loadLibrary(lib, this);
+    }
+  }
+
+  /**
+   * This method is called by SDL before starting the native application thread.
+   * It can be overridden to provide the arguments after the application name.
+   * The default implementation returns an empty array. It never returns null.
+   *
+   * @return arguments for the native application.
+   */
+  protected String[] getArguments() {
+    return new String[0];
+  }
+
+  protected SDLSurface createSDLSurface(Context context) {
+    return new SDLSurface(context);
+  }
+
+  // Setup
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    Log.v(TAG, "Device: " + Build.DEVICE);
+    Log.v(TAG, "Model: " + Build.MODEL);
+    Log.v(TAG, "onCreate()");
+    super.onCreate(savedInstanceState);
+
+    try {
+      Thread.currentThread().setName("SDLActivity");
+    } catch (Exception e) {
+      Log.v(TAG, "modify thread properties failed " + e);
+    }
+
+    // Load shared libraries
+    String errorMsgBrokenLib = "";
+    try {
+      loadLibraries();
+      mBrokenLibraries = false; /* success */
+    } catch (UnsatisfiedLinkError e) {
+      System.err.println(e.getMessage());
+      mBrokenLibraries = true;
+      errorMsgBrokenLib = e.getMessage();
+    } catch (Exception e) {
+      System.err.println(e.getMessage());
+      mBrokenLibraries = true;
+      errorMsgBrokenLib = e.getMessage();
+    }
+
+    if (!mBrokenLibraries) {
+      String expected_version = SDL_MAJOR_VERSION + "." +
+        SDL_MINOR_VERSION + "." +
+        SDL_MICRO_VERSION;
+      String version = nativeGetVersion();
+      if (!version.equals(expected_version)) {
+        mBrokenLibraries = true;
+        errorMsgBrokenLib = "SDL C/Java version mismatch (expected " + expected_version + ", got " + version + ")";
+      }
+    }
+
+    if (mBrokenLibraries) {
+      mSingleton = this;
+      AlertDialog.Builder dlgAlert = new AlertDialog.Builder(this);
+      dlgAlert.setMessage("An error occurred while trying to start the application. Please try again and/or reinstall."
+        + System.getProperty("line.separator")
+        + System.getProperty("line.separator")
+        + "Error: " + errorMsgBrokenLib);
+      dlgAlert.setTitle("SDL Error");
+      dlgAlert.setPositiveButton("Exit",
+        new DialogInterface.OnClickListener() {
+          @Override
+          public void onClick(DialogInterface dialog, int id) {
+            // if this button is clicked, close current activity
+            SDLActivity.mSingleton.finish();
+          }
+        });
+      dlgAlert.setCancelable(false);
+      dlgAlert.create().show();
+
+      return;
+    }
+
+    // Set up JNI
+    SDL.setupJNI();
+
+    // Initialize state
+    SDL.initialize();
+
+    // So we can call stuff from static callbacks
+    mSingleton = this;
+    SDL.setContext(this);
+
+    mClipboardHandler = new SDLClipboardHandler();
+
+    mHIDDeviceManager = HIDDeviceManager.acquire(this);
+
+    // Set up the surface
+    mSurface = createSDLSurface(this);
+
+    mLayout = new RelativeLayout(this);
+    mLayout.addView(mSurface);
+
+    // Get our current screen orientation and pass it down.
+    mCurrentOrientation = SDLActivity.getCurrentOrientation();
+    // Only record current orientation
+    SDLActivity.onNativeOrientationChanged(mCurrentOrientation);
+
+    try {
+      if (Build.VERSION.SDK_INT < 24 /* Android 7.0 (N) */) {
+        mCurrentLocale = getContext().getResources().getConfiguration().locale;
+      } else {
+        mCurrentLocale = getContext().getResources().getConfiguration().getLocales().get(0);
+      }
+    } catch (Exception ignored) {
+    }
+
+    setContentView(mLayout);
+
+    setWindowStyle(false);
+
+    getWindow().getDecorView().setOnSystemUiVisibilityChangeListener(this);
+
+    // Get filename from "Open with" of another application
+    Intent intent = getIntent();
+    if (intent != null && intent.getData() != null) {
+      String filename = intent.getData().getPath();
+      if (filename != null) {
+        Log.v(TAG, "Got filename: " + filename);
+        SDLActivity.onNativeDropFile(filename);
+      }
+    }
+  }
+
+  protected void pauseNativeThread() {
+    mNextNativeState = NativeState.PAUSED;
+    mIsResumedCalled = false;
+
+    if (SDLActivity.mBrokenLibraries) {
+      return;
+    }
+
+    SDLActivity.handleNativeState();
+  }
+
+  protected void resumeNativeThread() {
+    mNextNativeState = NativeState.RESUMED;
+    mIsResumedCalled = true;
+
+    if (SDLActivity.mBrokenLibraries) {
+      return;
+    }
+
+    SDLActivity.handleNativeState();
+  }
+
+  // Events
+  @Override
+  protected void onPause() {
+    Log.v(TAG, "onPause()");
+    super.onPause();
+
+    if (mHIDDeviceManager != null) {
+      mHIDDeviceManager.setFrozen(true);
+    }
+    if (!mHasMultiWindow) {
+      pauseNativeThread();
+    }
+  }
+
+  @Override
+  protected void onResume() {
+    Log.v(TAG, "onResume()");
+    super.onResume();
+
+    if (mHIDDeviceManager != null) {
+      mHIDDeviceManager.setFrozen(false);
+    }
+    if (!mHasMultiWindow) {
+      resumeNativeThread();
+    }
+  }
+
+  @Override
+  protected void onStop() {
+    Log.v(TAG, "onStop()");
+    super.onStop();
+    if (mHasMultiWindow) {
+      pauseNativeThread();
+    }
+  }
+
+  @Override
+  protected void onStart() {
+    Log.v(TAG, "onStart()");
+    super.onStart();
+    if (mHasMultiWindow) {
+      resumeNativeThread();
+    }
+  }
+
+  @Override
+  public void onWindowFocusChanged(boolean hasFocus) {
+    super.onWindowFocusChanged(hasFocus);
+    Log.v(TAG, "onWindowFocusChanged(): " + hasFocus);
+
+    if (SDLActivity.mBrokenLibraries) {
+      return;
+    }
+
+    mHasFocus = hasFocus;
+    if (hasFocus) {
+      mNextNativeState = NativeState.RESUMED;
+      SDLActivity.getMotionListener().reclaimRelativeMouseModeIfNeeded();
+
+      SDLActivity.handleNativeState();
+      nativeFocusChanged(true);
+
+    } else {
+      nativeFocusChanged(false);
+      if (!mHasMultiWindow) {
+        mNextNativeState = NativeState.PAUSED;
+        SDLActivity.handleNativeState();
+      }
+    }
+  }
+
+  // Input
+
+  @Override
+  public void onLowMemory() {
+    Log.v(TAG, "onLowMemory()");
+    super.onLowMemory();
+
+    if (SDLActivity.mBrokenLibraries) {
+      return;
+    }
+
+    SDLActivity.nativeLowMemory();
+  }
+
+  // Messagebox
+
+  @Override
+  public void onConfigurationChanged(Configuration newConfig) {
+    Log.v(TAG, "onConfigurationChanged()");
+    super.onConfigurationChanged(newConfig);
+
+    if (SDLActivity.mBrokenLibraries) {
+      return;
+    }
+
+    if (mCurrentLocale == null || !mCurrentLocale.equals(newConfig.locale)) {
+      mCurrentLocale = newConfig.locale;
+      SDLActivity.onNativeLocaleChanged();
+    }
+  }
+
+  @Override
+  protected void onDestroy() {
+    Log.v(TAG, "onDestroy()");
+
+    if (mHIDDeviceManager != null) {
+      HIDDeviceManager.release(mHIDDeviceManager);
+      mHIDDeviceManager = null;
+    }
+
+    SDLAudioManager.release(this);
+
+    if (SDLActivity.mBrokenLibraries) {
+      super.onDestroy();
+      return;
+    }
+
+    if (SDLActivity.mSDLThread != null) {
+
+      // Send Quit event to "SDLThread" thread
+      SDLActivity.nativeSendQuit();
+
+      // Wait for "SDLThread" thread to end
+      try {
+        SDLActivity.mSDLThread.join();
+      } catch (Exception e) {
+        Log.v(TAG, "Problem stopping SDLThread: " + e);
+      }
+    }
+
+    SDLActivity.nativeQuit();
+
+    super.onDestroy();
+  }
+
+  @Override
+  public void onBackPressed() {
+    // Check if we want to block the back button in case of mouse right click.
+    //
+    // If we do, the normal hardware back button will no longer work and people have to use home,
+    // but the mouse right click will work.
+    //
+    boolean trapBack = SDLActivity.nativeGetHintBoolean("SDL_ANDROID_TRAP_BACK_BUTTON", false);
+    if (trapBack) {
+      // Exit and let the mouse handler handle this button (if appropriate)
+      return;
+    }
+
+    // Default system back button behavior.
+    if (!isFinishing()) {
+      super.onBackPressed();
+    }
+  }
+
+  // Used to get us onto the activity's main thread
+  public void pressBackButton() {
+    runOnUiThread(new Runnable() {
+      @Override
+      public void run() {
+        if (!SDLActivity.this.isFinishing()) {
+          SDLActivity.this.superOnBackPressed();
+        }
+      }
+    });
+  }
+
+  // Used to access the system back behavior.
+  public void superOnBackPressed() {
+    super.onBackPressed();
+  }
+
+  @Override
+  public boolean dispatchKeyEvent(KeyEvent event) {
+
+    if (SDLActivity.mBrokenLibraries) {
+      return false;
+    }
+
+    int keyCode = event.getKeyCode();
+    // Ignore certain special keys so they're handled by Android
+    if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN ||
+      keyCode == KeyEvent.KEYCODE_VOLUME_UP ||
+      keyCode == KeyEvent.KEYCODE_CAMERA ||
+      keyCode == KeyEvent.KEYCODE_ZOOM_IN || /* API 11 */
+      keyCode == KeyEvent.KEYCODE_ZOOM_OUT /* API 11 */
+    ) {
+      return false;
+    }
+    return super.dispatchKeyEvent(event);
+  }
+
+  /**
+   * This method is called by SDL if SDL did not handle a message itself.
+   * This happens if a received message contains an unsupported command.
+   * Method can be overwritten to handle Messages in a different class.
+   *
+   * @param command the command of the message.
+   * @param param   the parameter of the message. May be null.
+   * @return if the message was handled in overridden method.
+   */
+  protected boolean onUnhandledMessage(int command, Object param) {
+    return false;
+  }
+
+  // Send a message from the SDLMain thread
+  boolean sendCommand(int command, Object data) {
+    Message msg = commandHandler.obtainMessage();
+    msg.arg1 = command;
+    msg.obj = data;
+    boolean result = commandHandler.sendMessage(msg);
+
+    if (Build.VERSION.SDK_INT >= 19 /* Android 4.4 (KITKAT) */) {
+      if (command == COMMAND_CHANGE_WINDOW_STYLE) {
+        // Ensure we don't return until the resize has actually happened,
+        // or 500ms have passed.
+
+        boolean bShouldWait = false;
+
+        if (data instanceof Integer) {
+          // Let's figure out if we're already laid out fullscreen or not.
+          Display display = ((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
+          DisplayMetrics realMetrics = new DisplayMetrics();
+          display.getRealMetrics(realMetrics);
+
+          boolean bFullscreenLayout = ((realMetrics.widthPixels == mSurface.getWidth()) &&
+            (realMetrics.heightPixels == mSurface.getHeight()));
+
+          if ((Integer) data == 1) {
+            // If we aren't laid out fullscreen or actively in fullscreen mode already, we're going
+            // to change size and should wait for surfaceChanged() before we return, so the size
+            // is right back in native code.  If we're already laid out fullscreen, though, we're
+            // not going to change size even if we change decor modes, so we shouldn't wait for
+            // surfaceChanged() -- which may not even happen -- and should return immediately.
+            bShouldWait = !bFullscreenLayout;
+          } else {
+            // If we're laid out fullscreen (even if the status bar and nav bar are present),
+            // or are actively in fullscreen, we're going to change size and should wait for
+            // surfaceChanged before we return, so the size is right back in native code.
+            bShouldWait = bFullscreenLayout;
+          }
+        }
+
+        if (bShouldWait && (SDLActivity.getContext() != null)) {
+          // We'll wait for the surfaceChanged() method, which will notify us
+          // when called.  That way, we know our current size is really the
+          // size we need, instead of grabbing a size that's still got
+          // the navigation and/or status bars before they're hidden.
+          //
+          // We'll wait for up to half a second, because some devices
+          // take a surprisingly long time for the surface resize, but
+          // then we'll just give up and return.
+          //
+          synchronized (SDLActivity.getContext()) {
+            try {
+              SDLActivity.getContext().wait(500);
+            } catch (InterruptedException ie) {
+              ie.printStackTrace();
+            }
+          }
+        }
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * This can be overridden
+   */
+  public void setOrientationBis(int w, int h, boolean resizable, String hint) {
+    int orientation_landscape = -1;
+    int orientation_portrait = -1;
+
+    /* If set, hint "explicitly controls which UI orientations are allowed". */
+    if (hint.contains("LandscapeRight") && hint.contains("LandscapeLeft")) {
+      orientation_landscape = ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE;
+    } else if (hint.contains("LandscapeLeft")) {
+      orientation_landscape = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE;
+    } else if (hint.contains("LandscapeRight")) {
+      orientation_landscape = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE;
+    }
+
+    /* exact match to 'Portrait' to distinguish with PortraitUpsideDown */
+    boolean contains_Portrait = hint.contains("Portrait ") || hint.endsWith("Portrait");
+
+    if (contains_Portrait && hint.contains("PortraitUpsideDown")) {
+      orientation_portrait = ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT;
+    } else if (contains_Portrait) {
+      orientation_portrait = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT;
+    } else if (hint.contains("PortraitUpsideDown")) {
+      orientation_portrait = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT;
+    }
+
+    boolean is_landscape_allowed = (orientation_landscape != -1);
+    boolean is_portrait_allowed = (orientation_portrait != -1);
+    int req; /* Requested orientation */
+
+    /* No valid hint, nothing is explicitly allowed */
+    if (!is_portrait_allowed && !is_landscape_allowed) {
+      if (resizable) {
+        /* All orientations are allowed, respecting user orientation lock setting */
+        req = ActivityInfo.SCREEN_ORIENTATION_FULL_USER;
+      } else {
+        /* Fixed window and nothing specified. Get orientation from w/h of created window */
+        req = (w > h ? ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE : ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
+      }
+    } else {
+      /* At least one orientation is allowed */
+      if (resizable) {
+        if (is_portrait_allowed && is_landscape_allowed) {
+          /* hint allows both landscape and portrait, promote to full user */
+          req = ActivityInfo.SCREEN_ORIENTATION_FULL_USER;
+        } else {
+          /* Use the only one allowed "orientation" */
+          req = (is_landscape_allowed ? orientation_landscape : orientation_portrait);
+        }
+      } else {
+        /* Fixed window and both orientations are allowed. Choose one. */
+        if (is_portrait_allowed && is_landscape_allowed) {
+          req = (w > h ? orientation_landscape : orientation_portrait);
+        } else {
+          /* Use the only one allowed "orientation" */
+          req = (is_landscape_allowed ? orientation_landscape : orientation_portrait);
+        }
+      }
+    }
+
+    Log.v(TAG, "setOrientation() requestedOrientation=" + req + " width=" + w + " height=" + h + " resizable=" + resizable + " hint=" + hint);
+    mSingleton.setRequestedOrientation(req);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   * Shows the messagebox from UI thread and block calling thread.
+   * buttonFlags, buttonIds and buttonTexts must have same length.
+   *
+   * @param buttonFlags array containing flags for every button.
+   * @param buttonIds   array containing id for every button.
+   * @param buttonTexts array containing text for every button.
+   * @param colors      null for default or array of length 5 containing colors.
+   * @return button id or -1.
+   */
+  public int messageboxShowMessageBox(
+    final int flags,
+    final String title,
+    final String message,
+    final int[] buttonFlags,
+    final int[] buttonIds,
+    final String[] buttonTexts,
+    final int[] colors) {
+
+    messageboxSelection[0] = -1;
+
+    // sanity checks
+
+    if ((buttonFlags.length != buttonIds.length) && (buttonIds.length != buttonTexts.length)) {
+      return -1; // implementation broken
+    }
+
+    // collect arguments for Dialog
+
+    final Bundle args = new Bundle();
+    args.putInt("flags", flags);
+    args.putString("title", title);
+    args.putString("message", message);
+    args.putIntArray("buttonFlags", buttonFlags);
+    args.putIntArray("buttonIds", buttonIds);
+    args.putStringArray("buttonTexts", buttonTexts);
+    args.putIntArray("colors", colors);
+
+    // trigger Dialog creation on UI thread
+
+    runOnUiThread(new Runnable() {
+      @Override
+      public void run() {
+        messageboxCreateAndShow(args);
+      }
+    });
+
+    // block the calling thread
+
+    synchronized (messageboxSelection) {
+      try {
+        messageboxSelection.wait();
+      } catch (InterruptedException ex) {
+        ex.printStackTrace();
+        return -1;
+      }
+    }
+
+    // return selected value
+
+    return messageboxSelection[0];
+  }
+
+  protected void messageboxCreateAndShow(Bundle args) {
+
+    // TODO set values from "flags" to messagebox dialog
+
+    // get colors
+
+    int[] colors = args.getIntArray("colors");
+    int backgroundColor;
+    int textColor;
+    int buttonBorderColor;
+    int buttonBackgroundColor;
+    int buttonSelectedColor;
+    if (colors != null) {
+      int i = -1;
+      backgroundColor = colors[++i];
+      textColor = colors[++i];
+      buttonBorderColor = colors[++i];
+      buttonBackgroundColor = colors[++i];
+      buttonSelectedColor = colors[++i];
+    } else {
+      backgroundColor = Color.TRANSPARENT;
+      textColor = Color.TRANSPARENT;
+      buttonBorderColor = Color.TRANSPARENT;
+      buttonBackgroundColor = Color.TRANSPARENT;
+      buttonSelectedColor = Color.TRANSPARENT;
+    }
+
+    // create dialog with title and a listener to wake up calling thread
+
+    final AlertDialog dialog = new AlertDialog.Builder(this).create();
+    dialog.setTitle(args.getString("title"));
+    dialog.setCancelable(false);
+    dialog.setOnDismissListener(new DialogInterface.OnDismissListener() {
+      @Override
+      public void onDismiss(DialogInterface unused) {
+        synchronized (messageboxSelection) {
+          messageboxSelection.notify();
+        }
+      }
+    });
+
+    // create text
+
+    TextView message = new TextView(this);
+    message.setGravity(Gravity.CENTER);
+    message.setText(args.getString("message"));
+    if (textColor != Color.TRANSPARENT) {
+      message.setTextColor(textColor);
+    }
+
+    // create buttons
+
+    int[] buttonFlags = args.getIntArray("buttonFlags");
+    int[] buttonIds = args.getIntArray("buttonIds");
+    String[] buttonTexts = args.getStringArray("buttonTexts");
+
+    final SparseArray<Button> mapping = new SparseArray<Button>();
+
+    LinearLayout buttons = new LinearLayout(this);
+    buttons.setOrientation(LinearLayout.HORIZONTAL);
+    buttons.setGravity(Gravity.CENTER);
+    for (int i = 0; i < buttonTexts.length; ++i) {
+      Button button = new Button(this);
+      final int id = buttonIds[i];
+      button.setOnClickListener(new View.OnClickListener() {
+        @Override
+        public void onClick(View v) {
+          messageboxSelection[0] = id;
+          dialog.dismiss();
+        }
+      });
+      if (buttonFlags[i] != 0) {
+        // see SDL_messagebox.h
+        if ((buttonFlags[i] & 0x00000001) != 0) {
+          mapping.put(KeyEvent.KEYCODE_ENTER, button);
+        }
+        if ((buttonFlags[i] & 0x00000002) != 0) {
+          mapping.put(KeyEvent.KEYCODE_ESCAPE, button); /* API 11 */
+        }
+      }
+      button.setText(buttonTexts[i]);
+      if (textColor != Color.TRANSPARENT) {
+        button.setTextColor(textColor);
+      }
+      if (buttonBorderColor != Color.TRANSPARENT) {
+        // TODO set color for border of messagebox button
+      }
+      if (buttonBackgroundColor != Color.TRANSPARENT) {
+        Drawable drawable = button.getBackground();
+        if (drawable == null) {
+          // setting the color this way removes the style
+          button.setBackgroundColor(buttonBackgroundColor);
+        } else {
+          // setting the color this way keeps the style (gradient, padding, etc.)
+          drawable.setColorFilter(buttonBackgroundColor, PorterDuff.Mode.MULTIPLY);
+        }
+      }
+      if (buttonSelectedColor != Color.TRANSPARENT) {
+        // TODO set color for selected messagebox button
+      }
+      buttons.addView(button);
+    }
+
+    // create content
+
+    LinearLayout content = new LinearLayout(this);
+    content.setOrientation(LinearLayout.VERTICAL);
+    content.addView(message);
+    content.addView(buttons);
+    if (backgroundColor != Color.TRANSPARENT) {
+      content.setBackgroundColor(backgroundColor);
+    }
+
+    // add content to dialog and return
+
+    dialog.setView(content);
+    dialog.setOnKeyListener(new Dialog.OnKeyListener() {
+      @Override
+      public boolean onKey(DialogInterface d, int keyCode, KeyEvent event) {
+        Button button = mapping.get(keyCode);
+        if (button != null) {
+          if (event.getAction() == KeyEvent.ACTION_UP) {
+            button.performClick();
+          }
+          return true; // also for ignored actions
+        }
+        return false;
+      }
+    });
+
+    dialog.show();
+  }
+
+  public void onSystemUiVisibilityChange(int visibility) {
+    if (SDLActivity.mFullscreenModeActive && ((visibility & View.SYSTEM_UI_FLAG_FULLSCREEN) == 0 || (visibility & View.SYSTEM_UI_FLAG_HIDE_NAVIGATION) == 0)) {
+
+      Handler handler = getWindow().getDecorView().getHandler();
+      if (handler != null) {
+        handler.removeCallbacks(rehideSystemUi); // Prevent a hide loop.
+        handler.postDelayed(rehideSystemUi, 2000);
+      }
+
+    }
+  }
+
+  @Override
+  public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+    boolean result = (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED);
+    nativePermissionResult(requestCode, result);
+  }
+
+  // Handle the state of the native layer
+  public enum NativeState {
+    INIT, RESUMED, PAUSED
+  }
+
+  /**
+   * A Handler class for Messages from native SDL applications.
+   * It uses current Activities as target (e.g. for the title).
+   * static to prevent implicit references to enclosing object.
+   */
+  protected static class SDLCommandHandler extends Handler {
+    @Override
+    public void handleMessage(Message msg) {
+      Context context = SDL.getContext();
+      if (context == null) {
+        Log.e(TAG, "error handling message, getContext() returned null");
+        return;
+      }
+      switch (msg.arg1) {
+        case COMMAND_CHANGE_TITLE:
+          if (context instanceof Activity) {
+            ((Activity) context).setTitle((String) msg.obj);
+          } else {
+            Log.e(TAG, "error handling message, getContext() returned no Activity");
+          }
+          break;
+        case COMMAND_CHANGE_WINDOW_STYLE:
+          if (Build.VERSION.SDK_INT >= 19 /* Android 4.4 (KITKAT) */) {
+            if (context instanceof Activity) {
+              Window window = ((Activity) context).getWindow();
+              if (window != null) {
+                if ((msg.obj instanceof Integer) && ((Integer) msg.obj != 0)) {
+                  int flags = View.SYSTEM_UI_FLAG_FULLSCREEN |
+                    View.SYSTEM_UI_FLAG_HIDE_NAVIGATION |
+                    View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY |
+                    View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN |
+                    View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
+                    View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.INVISIBLE;
+                  window.getDecorView().setSystemUiVisibility(flags);
+                  window.addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
+                  window.clearFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
+                  SDLActivity.mFullscreenModeActive = true;
+                } else {
+                  int flags = View.SYSTEM_UI_FLAG_LAYOUT_STABLE | View.SYSTEM_UI_FLAG_VISIBLE;
+                  window.getDecorView().setSystemUiVisibility(flags);
+                  window.addFlags(WindowManager.LayoutParams.FLAG_FORCE_NOT_FULLSCREEN);
+                  window.clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
+                  SDLActivity.mFullscreenModeActive = false;
+                }
+              }
+            } else {
+              Log.e(TAG, "error handling message, getContext() returned no Activity");
+            }
+          }
+          break;
+        case COMMAND_TEXTEDIT_HIDE:
+          if (mTextEdit != null) {
+            // Note: On some devices setting view to GONE creates a flicker in landscape.
+            // Setting the View's sizes to 0 is similar to GONE but without the flicker.
+            // The sizes will be set to useful values when the keyboard is shown again.
+            mTextEdit.setLayoutParams(new RelativeLayout.LayoutParams(0, 0));
+
+            InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
+            imm.hideSoftInputFromWindow(mTextEdit.getWindowToken(), 0);
+
+            mScreenKeyboardShown = false;
+
+            mSurface.requestFocus();
+          }
+          break;
+        case COMMAND_SET_KEEP_SCREEN_ON: {
+          if (context instanceof Activity) {
+            Window window = ((Activity) context).getWindow();
+            if (window != null) {
+              if ((msg.obj instanceof Integer) && ((Integer) msg.obj != 0)) {
+                window.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+              } else {
+                window.clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+              }
+            }
+          }
+          break;
+        }
+        default:
+          if ((context instanceof SDLActivity) && !((SDLActivity) context).onUnhandledMessage(msg.arg1, msg.obj)) {
+            Log.e(TAG, "error handling message, command is " + msg.arg1);
+          }
+      }
+    }
+  }
+
+  static class ShowTextInputTask implements Runnable {
+    /*
+     * This is used to regulate the pan&scan method to have some offset from
+     * the bottom edge of the input region and the top edge of an input
+     * method (soft keyboard)
+     */
+    static final int HEIGHT_PADDING = 15;
+
+    public int x, y, w, h;
+
+    public ShowTextInputTask(int x, int y, int w, int h) {
+      this.x = x;
+      this.y = y;
+      this.w = w;
+      this.h = h;
+
+      /* Minimum size of 1 pixel, so it takes focus. */
+      if (this.w <= 0) {
+        this.w = 1;
+      }
+      if (this.h + HEIGHT_PADDING <= 0) {
+        this.h = 1 - HEIGHT_PADDING;
+      }
+    }
+
+    @Override
+    public void run() {
+      RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(w, h + HEIGHT_PADDING);
+      params.leftMargin = x;
+      params.topMargin = y;
+
+      if (mTextEdit == null) {
+        mTextEdit = new DummyEdit(SDL.getContext());
+
+        mLayout.addView(mTextEdit, params);
+      } else {
+        mTextEdit.setLayoutParams(params);
+      }
+
+      mTextEdit.setVisibility(View.VISIBLE);
+      mTextEdit.requestFocus();
+
+      InputMethodManager imm = (InputMethodManager) SDL.getContext().getSystemService(Context.INPUT_METHOD_SERVICE);
+      imm.showSoftInput(mTextEdit, 0);
+
+      mScreenKeyboardShown = true;
+    }
+  }
+}
+
+/**
+ * Simple runnable to start the SDL application
+ */
+class SDLMain implements Runnable {
+  @Override
+  public void run() {
+    // Runs SDL_main()
+    String library = SDLActivity.mSingleton.getMainSharedObject();
+    String function = SDLActivity.mSingleton.getMainFunction();
+    String[] arguments = SDLActivity.mSingleton.getArguments();
+
+    try {
+      android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_DISPLAY);
+    } catch (Exception e) {
+      Log.v("SDL", "modify thread properties failed " + e);
+    }
+
+    Log.v("SDL", "Running main function " + function + " from library " + library);
+
+    SDLActivity.nativeRunMain(library, function, arguments);
+
+    Log.v("SDL", "Finished main function");
+
+    if (SDLActivity.mSingleton != null && !SDLActivity.mSingleton.isFinishing()) {
+      // Let's finish the Activity
+      SDLActivity.mSDLThread = null;
+      SDLActivity.mSingleton.finish();
+    }  // else: Activity is already being destroyed
+
+  }
+}
+
+/* This is a fake invisible editor view that receives the input and defines the
+ * pan&scan region
+ */
+class DummyEdit extends View implements View.OnKeyListener {
+  InputConnection ic;
+
+  public DummyEdit(Context context) {
+    super(context);
+    setFocusableInTouchMode(true);
+    setFocusable(true);
+    setOnKeyListener(this);
+  }
+
+  @Override
+  public boolean onCheckIsTextEditor() {
+    return true;
+  }
+
+  @Override
+  public boolean onKey(View v, int keyCode, KeyEvent event) {
+    return SDLActivity.handleKeyEvent(v, keyCode, event, ic);
+  }
+
+  //
+  @Override
+  public boolean onKeyPreIme(int keyCode, KeyEvent event) {
+    // As seen on StackOverflow: http://stackoverflow.com/questions/7634346/keyboard-hide-event
+    // FIXME: Discussion at http://bugzilla.libsdl.org/show_bug.cgi?id=1639
+    // FIXME: This is not a 100% effective solution to the problem of detecting if the keyboard is showing or not
+    // FIXME: A more effective solution would be to assume our Layout to be RelativeLayout or LinearLayout
+    // FIXME: And determine the keyboard presence doing this: http://stackoverflow.com/questions/2150078/how-to-check-visibility-of-software-keyboard-in-android
+    // FIXME: An even more effective way would be if Android provided this out of the box, but where would the fun be in that :)
+    if (event.getAction() == KeyEvent.ACTION_UP && keyCode == KeyEvent.KEYCODE_BACK) {
+      if (SDLActivity.mTextEdit != null && SDLActivity.mTextEdit.getVisibility() == View.VISIBLE) {
+        SDLActivity.onNativeKeyboardFocusLost();
+      }
+    }
+    return super.onKeyPreIme(keyCode, event);
+  }
+
+  @Override
+  public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
+    ic = new SDLInputConnection(this, true);
+
+    outAttrs.inputType = InputType.TYPE_CLASS_TEXT |
+      InputType.TYPE_TEXT_FLAG_MULTI_LINE;
+    outAttrs.imeOptions = EditorInfo.IME_FLAG_NO_EXTRACT_UI |
+      EditorInfo.IME_FLAG_NO_FULLSCREEN /* API 11 */;
+
+    return ic;
+  }
+}
+
+class SDLInputConnection extends BaseInputConnection {
+
+  protected EditText mEditText;
+  protected String mCommittedText = "";
+
+  public SDLInputConnection(View targetView, boolean fullEditor) {
+    super(targetView, fullEditor);
+    mEditText = new EditText(SDL.getContext());
+  }
+
+  public static native void nativeCommitText(String text, int newCursorPosition);
+
+  public static native void nativeGenerateScancodeForUnichar(char c);
+
+  @Override
+  public Editable getEditable() {
+    return mEditText.getEditableText();
+  }
+
+  @Override
+  public boolean sendKeyEvent(KeyEvent event) {
+    /*
+     * This used to handle the keycodes from soft keyboard (and IME-translated input from hardkeyboard)
+     * However, as of Ice Cream Sandwich and later, almost all soft keyboard doesn't generate key presses
+     * and so we need to generate them ourselves in commitText.  To avoid duplicates on the handful of keys
+     * that still do, we empty this out.
+     */
+
+    /*
+     * Return DOES still generate a key event, however.  So rather than using it as the 'click a button' key
+     * as we do with physical keyboards, let's just use it to hide the keyboard.
+     */
+
+    if (event.getKeyCode() == KeyEvent.KEYCODE_ENTER) {
+      if (SDLActivity.onNativeSoftReturnKey()) {
+        return true;
+      }
+    }
+
+    return super.sendKeyEvent(event);
+  }
+
+  @Override
+  public boolean commitText(CharSequence text, int newCursorPosition) {
+    if (!super.commitText(text, newCursorPosition)) {
+      return false;
+    }
+    updateText();
+    return true;
+  }
+
+  @Override
+  public boolean setComposingText(CharSequence text, int newCursorPosition) {
+    if (!super.setComposingText(text, newCursorPosition)) {
+      return false;
+    }
+    updateText();
+    return true;
+  }
+
+  @Override
+  public boolean deleteSurroundingText(int beforeLength, int afterLength) {
+    if (Build.VERSION.SDK_INT <= 29 /* Android 10.0 (Q) */) {
+      // Workaround to capture backspace key. Ref: http://stackoverflow.com/questions>/14560344/android-backspace-in-webview-baseinputconnection
+      // and https://bugzilla.libsdl.org/show_bug.cgi?id=2265
+      if (beforeLength > 0 && afterLength == 0) {
+        // backspace(s)
+        while (beforeLength-- > 0) {
+          nativeGenerateScancodeForUnichar('\b');
+        }
+        return true;
+      }
+    }
+
+    if (!super.deleteSurroundingText(beforeLength, afterLength)) {
+      return false;
+    }
+    updateText();
+    return true;
+  }
+
+  protected void updateText() {
+    final Editable content = getEditable();
+    if (content == null) {
+      return;
+    }
+
+    String text = content.toString();
+    int compareLength = Math.min(text.length(), mCommittedText.length());
+    int matchLength, offset;
+
+    /* Backspace over characters that are no longer in the string */
+    for (matchLength = 0; matchLength < compareLength; ) {
+      int codePoint = mCommittedText.codePointAt(matchLength);
+      if (codePoint != text.codePointAt(matchLength)) {
+        break;
+      }
+      matchLength += Character.charCount(codePoint);
+    }
+    /* FIXME: This doesn't handle graphemes, like '🌬️' */
+    for (offset = matchLength; offset < mCommittedText.length(); ) {
+      int codePoint = mCommittedText.codePointAt(offset);
+      nativeGenerateScancodeForUnichar('\b');
+      offset += Character.charCount(codePoint);
+    }
+
+    if (matchLength < text.length()) {
+      String pendingText = text.subSequence(matchLength, text.length()).toString();
+      for (offset = 0; offset < pendingText.length(); ) {
+        int codePoint = pendingText.codePointAt(offset);
+        if (codePoint == '\n') {
+          if (SDLActivity.onNativeSoftReturnKey()) {
+            return;
+          }
+        }
+        /* Higher code points don't generate simulated scancodes */
+        if (codePoint < 128) {
+          nativeGenerateScancodeForUnichar((char) codePoint);
+        }
+        offset += Character.charCount(codePoint);
+      }
+      SDLInputConnection.nativeCommitText(pendingText, 0);
+    }
+    mCommittedText = text;
+  }
+}
+
+class SDLClipboardHandler implements
+  ClipboardManager.OnPrimaryClipChangedListener {
+
+  protected ClipboardManager mClipMgr;
+
+  SDLClipboardHandler() {
+    mClipMgr = (ClipboardManager) SDL.getContext().getSystemService(Context.CLIPBOARD_SERVICE);
+    mClipMgr.addPrimaryClipChangedListener(this);
+  }
+
+  public boolean clipboardHasText() {
+    return mClipMgr.hasPrimaryClip();
+  }
+
+  public String clipboardGetText() {
+    ClipData clip = mClipMgr.getPrimaryClip();
+    if (clip != null) {
+      ClipData.Item item = clip.getItemAt(0);
+      if (item != null) {
+        CharSequence text = item.getText();
+        if (text != null) {
+          return text.toString();
+        }
+      }
+    }
+    return null;
+  }
+
+  public void clipboardSetText(String string) {
+    mClipMgr.removePrimaryClipChangedListener(this);
+    ClipData clip = ClipData.newPlainText(null, string);
+    mClipMgr.setPrimaryClip(clip);
+    mClipMgr.addPrimaryClipChangedListener(this);
+  }
+
+  @Override
+  public void onPrimaryClipChanged() {
+    SDLActivity.onNativeClipboardChanged();
+  }
+}
+
diff --git a/android/src/main/java/org/libsdl/app/SDLAudioManager.java b/android/src/main/java/org/libsdl/app/SDLAudioManager.java
new file mode 100644
index 000000000..1ef958e84
--- /dev/null
+++ b/android/src/main/java/org/libsdl/app/SDLAudioManager.java
@@ -0,0 +1,521 @@
+package org.libsdl.app;
+
+import android.content.Context;
+import android.media.AudioDeviceCallback;
+import android.media.AudioDeviceInfo;
+import android.media.AudioFormat;
+import android.media.AudioManager;
+import android.media.AudioRecord;
+import android.media.AudioTrack;
+import android.media.MediaRecorder;
+import android.os.Build;
+import android.util.Log;
+
+import java.util.Arrays;
+
+public class SDLAudioManager {
+  protected static final String TAG = "SDLAudio";
+  private static final int[] NO_DEVICES = {};
+  protected static AudioTrack mAudioTrack;
+  protected static AudioRecord mAudioRecord;
+  protected static Context mContext;
+  private static AudioDeviceCallback mAudioDeviceCallback;
+
+  public static void initialize() {
+    mAudioTrack = null;
+    mAudioRecord = null;
+    mAudioDeviceCallback = null;
+
+    if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+      mAudioDeviceCallback = new AudioDeviceCallback() {
+        @Override
+        public void onAudioDevicesAdded(AudioDeviceInfo[] addedDevices) {
+          Arrays.stream(addedDevices).forEach(deviceInfo -> addAudioDevice(deviceInfo.isSink(), deviceInfo.getId()));
+        }
+
+        @Override
+        public void onAudioDevicesRemoved(AudioDeviceInfo[] removedDevices) {
+          Arrays.stream(removedDevices).forEach(deviceInfo -> removeAudioDevice(deviceInfo.isSink(), deviceInfo.getId()));
+        }
+      };
+    }
+  }
+
+  public static void setContext(Context context) {
+    mContext = context;
+    if (context != null) {
+      registerAudioDeviceCallback();
+    }
+  }
+
+  public static void release(Context context) {
+    unregisterAudioDeviceCallback(context);
+  }
+
+  // Audio
+
+  protected static String getAudioFormatString(int audioFormat) {
+    switch (audioFormat) {
+      case AudioFormat.ENCODING_PCM_8BIT:
+        return "8-bit";
+      case AudioFormat.ENCODING_PCM_16BIT:
+        return "16-bit";
+      case AudioFormat.ENCODING_PCM_FLOAT:
+        return "float";
+      default:
+        return Integer.toString(audioFormat);
+    }
+  }
+
+  protected static int[] open(boolean isCapture, int sampleRate, int audioFormat, int desiredChannels, int desiredFrames, int deviceId) {
+    int channelConfig;
+    int sampleSize;
+    int frameSize;
+
+    Log.v(TAG, "Opening " + (isCapture ? "capture" : "playback") + ", requested " + desiredFrames + " frames of " + desiredChannels + " channel " + getAudioFormatString(audioFormat) + " audio at " + sampleRate + " Hz");
+
+    /* On older devices let's use known good settings */
+    if (Build.VERSION.SDK_INT < 21 /* Android 5.0 (LOLLIPOP) */) {
+      if (desiredChannels > 2) {
+        desiredChannels = 2;
+      }
+    }
+
+    /* AudioTrack has sample rate limitation of 48000 (fixed in 5.0.2) */
+    if (Build.VERSION.SDK_INT < 22 /* Android 5.1 (LOLLIPOP_MR1) */) {
+      if (sampleRate < 8000) {
+        sampleRate = 8000;
+      } else if (sampleRate > 48000) {
+        sampleRate = 48000;
+      }
+    }
+
+    if (audioFormat == AudioFormat.ENCODING_PCM_FLOAT) {
+      int minSDKVersion = (isCapture ? 23 /* Android 6.0 (M) */ : 21 /* Android 5.0 (LOLLIPOP) */);
+      if (Build.VERSION.SDK_INT < minSDKVersion) {
+        audioFormat = AudioFormat.ENCODING_PCM_16BIT;
+      }
+    }
+    switch (audioFormat) {
+      case AudioFormat.ENCODING_PCM_8BIT:
+        sampleSize = 1;
+        break;
+      case AudioFormat.ENCODING_PCM_16BIT:
+        sampleSize = 2;
+        break;
+      case AudioFormat.ENCODING_PCM_FLOAT:
+        sampleSize = 4;
+        break;
+      default:
+        Log.v(TAG, "Requested format " + audioFormat + ", getting ENCODING_PCM_16BIT");
+        audioFormat = AudioFormat.ENCODING_PCM_16BIT;
+        sampleSize = 2;
+        break;
+    }
+
+    if (isCapture) {
+      switch (desiredChannels) {
+        case 1:
+          channelConfig = AudioFormat.CHANNEL_IN_MONO;
+          break;
+        case 2:
+          channelConfig = AudioFormat.CHANNEL_IN_STEREO;
+          break;
+        default:
+          Log.v(TAG, "Requested " + desiredChannels + " channels, getting stereo");
+          desiredChannels = 2;
+          channelConfig = AudioFormat.CHANNEL_IN_STEREO;
+          break;
+      }
+    } else {
+      switch (desiredChannels) {
+        case 1:
+          channelConfig = AudioFormat.CHANNEL_OUT_MONO;
+          break;
+        case 2:
+          channelConfig = AudioFormat.CHANNEL_OUT_STEREO;
+          break;
+        case 3:
+          channelConfig = AudioFormat.CHANNEL_OUT_STEREO | AudioFormat.CHANNEL_OUT_FRONT_CENTER;
+          break;
+        case 4:
+          channelConfig = AudioFormat.CHANNEL_OUT_QUAD;
+          break;
+        case 5:
+          channelConfig = AudioFormat.CHANNEL_OUT_QUAD | AudioFormat.CHANNEL_OUT_FRONT_CENTER;
+          break;
+        case 6:
+          channelConfig = AudioFormat.CHANNEL_OUT_5POINT1;
+          break;
+        case 7:
+          channelConfig = AudioFormat.CHANNEL_OUT_5POINT1 | AudioFormat.CHANNEL_OUT_BACK_CENTER;
+          break;
+        case 8:
+          if (Build.VERSION.SDK_INT >= 23 /* Android 6.0 (M) */) {
+            channelConfig = AudioFormat.CHANNEL_OUT_7POINT1_SURROUND;
+          } else {
+            Log.v(TAG, "Requested " + desiredChannels + " channels, getting 5.1 surround");
+            desiredChannels = 6;
+            channelConfig = AudioFormat.CHANNEL_OUT_5POINT1;
+          }
+          break;
+        default:
+          Log.v(TAG, "Requested " + desiredChannels + " channels, getting stereo");
+          desiredChannels = 2;
+          channelConfig = AudioFormat.CHANNEL_OUT_STEREO;
+          break;
+      }
+
+/*
+            Log.v(TAG, "Speaker configuration (and order of channels):");
+
+            if ((channelConfig & 0x00000004) != 0) {
+                Log.v(TAG, "   CHANNEL_OUT_FRONT_LEFT");
+            }
+            if ((channelConfig & 0x00000008) != 0) {
+                Log.v(TAG, "   CHANNEL_OUT_FRONT_RIGHT");
+            }
+            if ((channelConfig & 0x00000010) != 0) {
+                Log.v(TAG, "   CHANNEL_OUT_FRONT_CENTER");
+            }
+            if ((channelConfig & 0x00000020) != 0) {
+                Log.v(TAG, "   CHANNEL_OUT_LOW_FREQUENCY");
+            }
+            if ((channelConfig & 0x00000040) != 0) {
+                Log.v(TAG, "   CHANNEL_OUT_BACK_LEFT");
+            }
+            if ((channelConfig & 0x00000080) != 0) {
+                Log.v(TAG, "   CHANNEL_OUT_BACK_RIGHT");
+            }
+            if ((channelConfig & 0x00000100) != 0) {
+                Log.v(TAG, "   CHANNEL_OUT_FRONT_LEFT_OF_CENTER");
+            }
+            if ((channelConfig & 0x00000200) != 0) {
+                Log.v(TAG, "   CHANNEL_OUT_FRONT_RIGHT_OF_CENTER");
+            }
+            if ((channelConfig & 0x00000400) != 0) {
+                Log.v(TAG, "   CHANNEL_OUT_BACK_CENTER");
+            }
+            if ((channelConfig & 0x00000800) != 0) {
+                Log.v(TAG, "   CHANNEL_OUT_SIDE_LEFT");
+            }
+            if ((channelConfig & 0x00001000) != 0) {
+                Log.v(TAG, "   CHANNEL_OUT_SIDE_RIGHT");
+            }
+*/
+    }
+    frameSize = (sampleSize * desiredChannels);
+
+    // Let the user pick a larger buffer if they really want -- but ye
+    // gods they probably shouldn't, the minimums are horrifyingly high
+    // latency already
+    int minBufferSize;
+    if (isCapture) {
+      minBufferSize = AudioRecord.getMinBufferSize(sampleRate, channelConfig, audioFormat);
+    } else {
+      minBufferSize = AudioTrack.getMinBufferSize(sampleRate, channelConfig, audioFormat);
+    }
+    desiredFrames = Math.max(desiredFrames, (minBufferSize + frameSize - 1) / frameSize);
+
+    int[] results = new int[4];
+
+    if (isCapture) {
+      if (mAudioRecord == null) {
+        mAudioRecord = new AudioRecord(MediaRecorder.AudioSource.DEFAULT, sampleRate,
+          channelConfig, audioFormat, desiredFrames * frameSize);
+
+        // see notes about AudioTrack state in audioOpen(), above. Probably also applies here.
+        if (mAudioRecord.getState() != AudioRecord.STATE_INITIALIZED) {
+          Log.e(TAG, "Failed during initialization of AudioRecord");
+          mAudioRecord.release();
+          mAudioRecord = null;
+          return null;
+        }
+
+        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */ && deviceId != 0) {
+          mAudioRecord.setPreferredDevice(getOutputAudioDeviceInfo(deviceId));
+        }
+
+        mAudioRecord.startRecording();
+      }
+
+      results[0] = mAudioRecord.getSampleRate();
+      results[1] = mAudioRecord.getAudioFormat();
+      results[2] = mAudioRecord.getChannelCount();
+
+    } else {
+      if (mAudioTrack == null) {
+        mAudioTrack = new AudioTrack(AudioManager.STREAM_MUSIC, sampleRate, channelConfig, audioFormat, desiredFrames * frameSize, AudioTrack.MODE_STREAM);
+
+        // Instantiating AudioTrack can "succeed" without an exception and the track may still be invalid
+        // Ref: https://android.googlesource.com/platform/frameworks/base/+/refs/heads/master/media/java/android/media/AudioTrack.java
+        // Ref: http://developer.android.com/reference/android/media/AudioTrack.html#getState()
+        if (mAudioTrack.getState() != AudioTrack.STATE_INITIALIZED) {
+          /* Try again, with safer values */
+
+          Log.e(TAG, "Failed during initialization of Audio Track");
+          mAudioTrack.release();
+          mAudioTrack = null;
+          return null;
+        }
+
+        if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */ && deviceId != 0) {
+          mAudioTrack.setPreferredDevice(getInputAudioDeviceInfo(deviceId));
+        }
+
+        mAudioTrack.play();
+      }
+
+      results[0] = mAudioTrack.getSampleRate();
+      results[1] = mAudioTrack.getAudioFormat();
+      results[2] = mAudioTrack.getChannelCount();
+    }
+    results[3] = desiredFrames;
+
+    Log.v(TAG, "Opening " + (isCapture ? "capture" : "playback") + ", got " + results[3] + " frames of " + results[2] + " channel " + getAudioFormatString(results[1]) + " audio at " + results[0] + " Hz");
+
+    return results;
+  }
+
+  private static AudioDeviceInfo getInputAudioDeviceInfo(int deviceId) {
+    if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+      AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
+      return Arrays.stream(audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS))
+        .filter(deviceInfo -> deviceInfo.getId() == deviceId)
+        .findFirst()
+        .orElse(null);
+    } else {
+      return null;
+    }
+  }
+
+  private static AudioDeviceInfo getOutputAudioDeviceInfo(int deviceId) {
+    if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+      AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
+      return Arrays.stream(audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS))
+        .filter(deviceInfo -> deviceInfo.getId() == deviceId)
+        .findFirst()
+        .orElse(null);
+    } else {
+      return null;
+    }
+  }
+
+  private static void registerAudioDeviceCallback() {
+    if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+      AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
+      audioManager.registerAudioDeviceCallback(mAudioDeviceCallback, null);
+    }
+  }
+
+  private static void unregisterAudioDeviceCallback(Context context) {
+    if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+      AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+      audioManager.unregisterAudioDeviceCallback(mAudioDeviceCallback);
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static int[] getAudioOutputDevices() {
+    if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+      AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
+      return Arrays.stream(audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS)).mapToInt(AudioDeviceInfo::getId).toArray();
+    } else {
+      return NO_DEVICES;
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static int[] getAudioInputDevices() {
+    if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+      AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
+      return Arrays.stream(audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)).mapToInt(AudioDeviceInfo::getId).toArray();
+    } else {
+      return NO_DEVICES;
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static int[] audioOpen(int sampleRate, int audioFormat, int desiredChannels, int desiredFrames, int deviceId) {
+    return open(false, sampleRate, audioFormat, desiredChannels, desiredFrames, deviceId);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void audioWriteFloatBuffer(float[] buffer) {
+    if (mAudioTrack == null) {
+      Log.e(TAG, "Attempted to make audio call with uninitialized audio!");
+      return;
+    }
+
+    if (android.os.Build.VERSION.SDK_INT < 21 /* Android 5.0 (LOLLIPOP) */) {
+      Log.e(TAG, "Attempted to make an incompatible audio call with uninitialized audio! (floating-point output is supported since Android 5.0 Lollipop)");
+      return;
+    }
+
+    for (int i = 0; i < buffer.length; ) {
+      int result = mAudioTrack.write(buffer, i, buffer.length - i, AudioTrack.WRITE_BLOCKING);
+      if (result > 0) {
+        i += result;
+      } else if (result == 0) {
+        try {
+          Thread.sleep(1);
+        } catch (InterruptedException e) {
+          // Nom nom
+        }
+      } else {
+        Log.w(TAG, "SDL audio: error return from write(float)");
+        return;
+      }
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void audioWriteShortBuffer(short[] buffer) {
+    if (mAudioTrack == null) {
+      Log.e(TAG, "Attempted to make audio call with uninitialized audio!");
+      return;
+    }
+
+    for (int i = 0; i < buffer.length; ) {
+      int result = mAudioTrack.write(buffer, i, buffer.length - i);
+      if (result > 0) {
+        i += result;
+      } else if (result == 0) {
+        try {
+          Thread.sleep(1);
+        } catch (InterruptedException e) {
+          // Nom nom
+        }
+      } else {
+        Log.w(TAG, "SDL audio: error return from write(short)");
+        return;
+      }
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void audioWriteByteBuffer(byte[] buffer) {
+    if (mAudioTrack == null) {
+      Log.e(TAG, "Attempted to make audio call with uninitialized audio!");
+      return;
+    }
+
+    for (int i = 0; i < buffer.length; ) {
+      int result = mAudioTrack.write(buffer, i, buffer.length - i);
+      if (result > 0) {
+        i += result;
+      } else if (result == 0) {
+        try {
+          Thread.sleep(1);
+        } catch (InterruptedException e) {
+          // Nom nom
+        }
+      } else {
+        Log.w(TAG, "SDL audio: error return from write(byte)");
+        return;
+      }
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static int[] captureOpen(int sampleRate, int audioFormat, int desiredChannels, int desiredFrames, int deviceId) {
+    return open(true, sampleRate, audioFormat, desiredChannels, desiredFrames, deviceId);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static int captureReadFloatBuffer(float[] buffer, boolean blocking) {
+    if (Build.VERSION.SDK_INT < 23 /* Android 6.0 (M) */) {
+      return 0;
+    } else {
+      return mAudioRecord.read(buffer, 0, buffer.length, blocking ? AudioRecord.READ_BLOCKING : AudioRecord.READ_NON_BLOCKING);
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static int captureReadShortBuffer(short[] buffer, boolean blocking) {
+    if (Build.VERSION.SDK_INT < 23 /* Android 6.0 (M) */) {
+      return mAudioRecord.read(buffer, 0, buffer.length);
+    } else {
+      return mAudioRecord.read(buffer, 0, buffer.length, blocking ? AudioRecord.READ_BLOCKING : AudioRecord.READ_NON_BLOCKING);
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static int captureReadByteBuffer(byte[] buffer, boolean blocking) {
+    if (Build.VERSION.SDK_INT < 23 /* Android 6.0 (M) */) {
+      return mAudioRecord.read(buffer, 0, buffer.length);
+    } else {
+      return mAudioRecord.read(buffer, 0, buffer.length, blocking ? AudioRecord.READ_BLOCKING : AudioRecord.READ_NON_BLOCKING);
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void audioClose() {
+    if (mAudioTrack != null) {
+      mAudioTrack.stop();
+      mAudioTrack.release();
+      mAudioTrack = null;
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void captureClose() {
+    if (mAudioRecord != null) {
+      mAudioRecord.stop();
+      mAudioRecord.release();
+      mAudioRecord = null;
+    }
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void audioSetThreadPriority(boolean iscapture, int device_id) {
+    try {
+
+      /* Set thread name */
+      if (iscapture) {
+        Thread.currentThread().setName("SDLAudioC" + device_id);
+      } else {
+        Thread.currentThread().setName("SDLAudioP" + device_id);
+      }
+
+      /* Set thread priority */
+      android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_AUDIO);
+
+    } catch (Exception e) {
+      Log.v(TAG, "modify thread properties failed " + e);
+    }
+  }
+
+  public static native int nativeSetupJNI();
+
+  public static native void removeAudioDevice(boolean isCapture, int deviceId);
+
+  public static native void addAudioDevice(boolean isCapture, int deviceId);
+
+}
diff --git a/android/src/main/java/org/libsdl/app/SDLControllerManager.java b/android/src/main/java/org/libsdl/app/SDLControllerManager.java
new file mode 100644
index 000000000..02fdabda6
--- /dev/null
+++ b/android/src/main/java/org/libsdl/app/SDLControllerManager.java
@@ -0,0 +1,863 @@
+package org.libsdl.app;
+
+import android.content.Context;
+import android.os.Build;
+import android.os.VibrationEffect;
+import android.os.Vibrator;
+import android.util.Log;
+import android.view.InputDevice;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.View;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+
+public class SDLControllerManager {
+
+  private static final String TAG = "SDLControllerManager";
+  protected static SDLJoystickHandler mJoystickHandler;
+  protected static SDLHapticHandler mHapticHandler;
+
+  public static native int nativeSetupJNI();
+
+  public static native int nativeAddJoystick(int device_id, String name, String desc,
+                                             int vendor_id, int product_id,
+                                             boolean is_accelerometer, int button_mask,
+                                             int naxes, int axis_mask, int nhats, int nballs);
+
+  public static native int nativeRemoveJoystick(int device_id);
+
+  public static native int nativeAddHaptic(int device_id, String name);
+
+  public static native int nativeRemoveHaptic(int device_id);
+
+  public static native int onNativePadDown(int device_id, int keycode);
+
+  public static native int onNativePadUp(int device_id, int keycode);
+
+  public static native void onNativeJoy(int device_id, int axis,
+                                        float value);
+
+  public static native void onNativeHat(int device_id, int hat_id,
+                                        int x, int y);
+
+  public static void initialize() {
+    if (mJoystickHandler == null) {
+      if (Build.VERSION.SDK_INT >= 19 /* Android 4.4 (KITKAT) */) {
+        mJoystickHandler = new SDLJoystickHandler_API19();
+      } else {
+        mJoystickHandler = new SDLJoystickHandler_API16();
+      }
+    }
+
+    if (mHapticHandler == null) {
+      if (Build.VERSION.SDK_INT >= 26 /* Android 8.0 (O) */) {
+        mHapticHandler = new SDLHapticHandler_API26();
+      } else {
+        mHapticHandler = new SDLHapticHandler();
+      }
+    }
+  }
+
+  // Joystick glue code, just a series of stubs that redirect to the SDLJoystickHandler instance
+  public static boolean handleJoystickMotionEvent(MotionEvent event) {
+    return mJoystickHandler.handleMotionEvent(event);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void pollInputDevices() {
+    mJoystickHandler.pollInputDevices();
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void pollHapticDevices() {
+    mHapticHandler.pollHapticDevices();
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void hapticRun(int device_id, float intensity, int length) {
+    mHapticHandler.run(device_id, intensity, length);
+  }
+
+  /**
+   * This method is called by SDL using JNI.
+   */
+  public static void hapticStop(int device_id) {
+    mHapticHandler.stop(device_id);
+  }
+
+  // Check if a given device is considered a possible SDL joystick
+  public static boolean isDeviceSDLJoystick(int deviceId) {
+    InputDevice device = InputDevice.getDevice(deviceId);
+    // We cannot use InputDevice.isVirtual before API 16, so let's accept
+    // only nonnegative device ids (VIRTUAL_KEYBOARD equals -1)
+    if ((device == null) || (deviceId < 0)) {
+      return false;
+    }
+    int sources = device.getSources();
+
+    /* This is called for every button press, so let's not spam the logs */
+        /*
+        if ((sources & InputDevice.SOURCE_CLASS_JOYSTICK) != 0) {
+            Log.v(TAG, "Input device " + device.getName() + " has class joystick.");
+        }
+        if ((sources & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD) {
+            Log.v(TAG, "Input device " + device.getName() + " is a dpad.");
+        }
+        if ((sources & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD) {
+            Log.v(TAG, "Input device " + device.getName() + " is a gamepad.");
+        }
+        */
+
+    return ((sources & InputDevice.SOURCE_CLASS_JOYSTICK) != 0 ||
+      ((sources & InputDevice.SOURCE_DPAD) == InputDevice.SOURCE_DPAD) ||
+      ((sources & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD)
+    );
+  }
+
+}
+
+class SDLJoystickHandler {
+
+  /**
+   * Handles given MotionEvent.
+   *
+   * @param event the event to be handled.
+   * @return if given event was processed.
+   */
+  public boolean handleMotionEvent(MotionEvent event) {
+    return false;
+  }
+
+  /**
+   * Handles adding and removing of input devices.
+   */
+  public void pollInputDevices() {
+  }
+}
+
+/* Actual joystick functionality available for API >= 12 devices */
+class SDLJoystickHandler_API16 extends SDLJoystickHandler {
+
+  private final ArrayList<SDLJoystick> mJoysticks;
+
+  public SDLJoystickHandler_API16() {
+
+    mJoysticks = new ArrayList<SDLJoystick>();
+  }
+
+  @Override
+  public void pollInputDevices() {
+    int[] deviceIds = InputDevice.getDeviceIds();
+
+    for (int device_id : deviceIds) {
+      if (SDLControllerManager.isDeviceSDLJoystick(device_id)) {
+        SDLJoystick joystick = getJoystick(device_id);
+        if (joystick == null) {
+          InputDevice joystickDevice = InputDevice.getDevice(device_id);
+          joystick = new SDLJoystick();
+          joystick.device_id = device_id;
+          joystick.name = joystickDevice.getName();
+          joystick.desc = getJoystickDescriptor(joystickDevice);
+          joystick.axes = new ArrayList<InputDevice.MotionRange>();
+          joystick.hats = new ArrayList<InputDevice.MotionRange>();
+
+          List<InputDevice.MotionRange> ranges = joystickDevice.getMotionRanges();
+          Collections.sort(ranges, new RangeComparator());
+          for (InputDevice.MotionRange range : ranges) {
+            if ((range.getSource() & InputDevice.SOURCE_CLASS_JOYSTICK) != 0) {
+              if (range.getAxis() == MotionEvent.AXIS_HAT_X || range.getAxis() == MotionEvent.AXIS_HAT_Y) {
+                joystick.hats.add(range);
+              } else {
+                joystick.axes.add(range);
+              }
+            }
+          }
+
+          mJoysticks.add(joystick);
+          SDLControllerManager.nativeAddJoystick(joystick.device_id, joystick.name, joystick.desc,
+            getVendorId(joystickDevice), getProductId(joystickDevice), false,
+            getButtonMask(joystickDevice), joystick.axes.size(), getAxisMask(joystick.axes), joystick.hats.size() / 2, 0);
+        }
+      }
+    }
+
+    /* Check removed devices */
+    ArrayList<Integer> removedDevices = null;
+    for (SDLJoystick joystick : mJoysticks) {
+      int device_id = joystick.device_id;
+      int i;
+      for (i = 0; i < deviceIds.length; i++) {
+        if (device_id == deviceIds[i]) break;
+      }
+      if (i == deviceIds.length) {
+        if (removedDevices == null) {
+          removedDevices = new ArrayList<Integer>();
+        }
+        removedDevices.add(device_id);
+      }
+    }
+
+    if (removedDevices != null) {
+      for (int device_id : removedDevices) {
+        SDLControllerManager.nativeRemoveJoystick(device_id);
+        for (int i = 0; i < mJoysticks.size(); i++) {
+          if (mJoysticks.get(i).device_id == device_id) {
+            mJoysticks.remove(i);
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  protected SDLJoystick getJoystick(int device_id) {
+    for (SDLJoystick joystick : mJoysticks) {
+      if (joystick.device_id == device_id) {
+        return joystick;
+      }
+    }
+    return null;
+  }
+
+  @Override
+  public boolean handleMotionEvent(MotionEvent event) {
+    int actionPointerIndex = event.getActionIndex();
+    int action = event.getActionMasked();
+    if (action == MotionEvent.ACTION_MOVE) {
+      SDLJoystick joystick = getJoystick(event.getDeviceId());
+      if (joystick != null) {
+        for (int i = 0; i < joystick.axes.size(); i++) {
+          InputDevice.MotionRange range = joystick.axes.get(i);
+          /* Normalize the value to -1...1 */
+          float value = (event.getAxisValue(range.getAxis(), actionPointerIndex) - range.getMin()) / range.getRange() * 2.0f - 1.0f;
+          SDLControllerManager.onNativeJoy(joystick.device_id, i, value);
+        }
+        for (int i = 0; i < joystick.hats.size() / 2; i++) {
+          int hatX = Math.round(event.getAxisValue(joystick.hats.get(2 * i).getAxis(), actionPointerIndex));
+          int hatY = Math.round(event.getAxisValue(joystick.hats.get(2 * i + 1).getAxis(), actionPointerIndex));
+          SDLControllerManager.onNativeHat(joystick.device_id, i, hatX, hatY);
+        }
+      }
+    }
+    return true;
+  }
+
+  public String getJoystickDescriptor(InputDevice joystickDevice) {
+    String desc = joystickDevice.getDescriptor();
+
+    if (desc != null && !desc.isEmpty()) {
+      return desc;
+    }
+
+    return joystickDevice.getName();
+  }
+
+  public int getProductId(InputDevice joystickDevice) {
+    return 0;
+  }
+
+  public int getVendorId(InputDevice joystickDevice) {
+    return 0;
+  }
+
+  public int getAxisMask(List<InputDevice.MotionRange> ranges) {
+    return -1;
+  }
+
+  public int getButtonMask(InputDevice joystickDevice) {
+    return -1;
+  }
+
+  static class SDLJoystick {
+    public int device_id;
+    public String name;
+    public String desc;
+    public ArrayList<InputDevice.MotionRange> axes;
+    public ArrayList<InputDevice.MotionRange> hats;
+  }
+
+  static class RangeComparator implements Comparator<InputDevice.MotionRange> {
+    @Override
+    public int compare(InputDevice.MotionRange arg0, InputDevice.MotionRange arg1) {
+      // Some controllers, like the Moga Pro 2, return AXIS_GAS (22) for right trigger and AXIS_BRAKE (23) for left trigger - swap them so they're sorted in the right order for SDL
+      int arg0Axis = arg0.getAxis();
+      int arg1Axis = arg1.getAxis();
+      if (arg0Axis == MotionEvent.AXIS_GAS) {
+        arg0Axis = MotionEvent.AXIS_BRAKE;
+      } else if (arg0Axis == MotionEvent.AXIS_BRAKE) {
+        arg0Axis = MotionEvent.AXIS_GAS;
+      }
+      if (arg1Axis == MotionEvent.AXIS_GAS) {
+        arg1Axis = MotionEvent.AXIS_BRAKE;
+      } else if (arg1Axis == MotionEvent.AXIS_BRAKE) {
+        arg1Axis = MotionEvent.AXIS_GAS;
+      }
+
+      // Make sure the AXIS_Z is sorted between AXIS_RY and AXIS_RZ.
+      // This is because the usual pairing are:
+      // - AXIS_X + AXIS_Y (left stick).
+      // - AXIS_RX, AXIS_RY (sometimes the right stick, sometimes triggers).
+      // - AXIS_Z, AXIS_RZ (sometimes the right stick, sometimes triggers).
+      // This sorts the axes in the above order, which tends to be correct
+      // for Xbox-ish game pads that have the right stick on RX/RY and the
+      // triggers on Z/RZ.
+      //
+      // Gamepads that don't have AXIS_Z/AXIS_RZ but use
+      // AXIS_LTRIGGER/AXIS_RTRIGGER are unaffected by this.
+      //
+      // References:
+      // - https://developer.android.com/develop/ui/views/touch-and-input/game-controllers/controller-input
+      // - https://www.kernel.org/doc/html/latest/input/gamepad.html
+      if (arg0Axis == MotionEvent.AXIS_Z) {
+        arg0Axis = MotionEvent.AXIS_RZ - 1;
+      } else if (arg0Axis > MotionEvent.AXIS_Z && arg0Axis < MotionEvent.AXIS_RZ) {
+        --arg0Axis;
+      }
+      if (arg1Axis == MotionEvent.AXIS_Z) {
+        arg1Axis = MotionEvent.AXIS_RZ - 1;
+      } else if (arg1Axis > MotionEvent.AXIS_Z && arg1Axis < MotionEvent.AXIS_RZ) {
+        --arg1Axis;
+      }
+
+      return arg0Axis - arg1Axis;
+    }
+  }
+}
+
+class SDLJoystickHandler_API19 extends SDLJoystickHandler_API16 {
+
+  @Override
+  public int getProductId(InputDevice joystickDevice) {
+    return joystickDevice.getProductId();
+  }
+
+  @Override
+  public int getVendorId(InputDevice joystickDevice) {
+    return joystickDevice.getVendorId();
+  }
+
+  @Override
+  public int getAxisMask(List<InputDevice.MotionRange> ranges) {
+    // For compatibility, keep computing the axis mask like before,
+    // only really distinguishing 2, 4 and 6 axes.
+    int axis_mask = 0;
+    if (ranges.size() >= 2) {
+      // ((1 << SDL_GAMEPAD_AXIS_LEFTX) | (1 << SDL_GAMEPAD_AXIS_LEFTY))
+      axis_mask |= 0x0003;
+    }
+    if (ranges.size() >= 4) {
+      // ((1 << SDL_GAMEPAD_AXIS_RIGHTX) | (1 << SDL_GAMEPAD_AXIS_RIGHTY))
+      axis_mask |= 0x000c;
+    }
+    if (ranges.size() >= 6) {
+      // ((1 << SDL_GAMEPAD_AXIS_LEFT_TRIGGER) | (1 << SDL_GAMEPAD_AXIS_RIGHT_TRIGGER))
+      axis_mask |= 0x0030;
+    }
+    // Also add an indicator bit for whether the sorting order has changed.
+    // This serves to disable outdated gamecontrollerdb.txt mappings.
+    boolean have_z = false;
+    boolean have_past_z_before_rz = false;
+    for (InputDevice.MotionRange range : ranges) {
+      int axis = range.getAxis();
+      if (axis == MotionEvent.AXIS_Z) {
+        have_z = true;
+      } else if (axis > MotionEvent.AXIS_Z && axis < MotionEvent.AXIS_RZ) {
+        have_past_z_before_rz = true;
+      }
+    }
+    if (have_z && have_past_z_before_rz) {
+      // If both these exist, the compare() function changed sorting order.
+      // Set a bit to indicate this fact.
+      axis_mask |= 0x8000;
+    }
+    return axis_mask;
+  }
+
+  @Override
+  public int getButtonMask(InputDevice joystickDevice) {
+    int button_mask = 0;
+    int[] keys = new int[]{
+      KeyEvent.KEYCODE_BUTTON_A,
+      KeyEvent.KEYCODE_BUTTON_B,
+      KeyEvent.KEYCODE_BUTTON_X,
+      KeyEvent.KEYCODE_BUTTON_Y,
+      KeyEvent.KEYCODE_BACK,
+      KeyEvent.KEYCODE_MENU,
+      KeyEvent.KEYCODE_BUTTON_MODE,
+      KeyEvent.KEYCODE_BUTTON_START,
+      KeyEvent.KEYCODE_BUTTON_THUMBL,
+      KeyEvent.KEYCODE_BUTTON_THUMBR,
+      KeyEvent.KEYCODE_BUTTON_L1,
+      KeyEvent.KEYCODE_BUTTON_R1,
+      KeyEvent.KEYCODE_DPAD_UP,
+      KeyEvent.KEYCODE_DPAD_DOWN,
+      KeyEvent.KEYCODE_DPAD_LEFT,
+      KeyEvent.KEYCODE_DPAD_RIGHT,
+      KeyEvent.KEYCODE_BUTTON_SELECT,
+      KeyEvent.KEYCODE_DPAD_CENTER,
+
+      // These don't map into any SDL controller buttons directly
+      KeyEvent.KEYCODE_BUTTON_L2,
+      KeyEvent.KEYCODE_BUTTON_R2,
+      KeyEvent.KEYCODE_BUTTON_C,
+      KeyEvent.KEYCODE_BUTTON_Z,
+      KeyEvent.KEYCODE_BUTTON_1,
+      KeyEvent.KEYCODE_BUTTON_2,
+      KeyEvent.KEYCODE_BUTTON_3,
+      KeyEvent.KEYCODE_BUTTON_4,
+      KeyEvent.KEYCODE_BUTTON_5,
+      KeyEvent.KEYCODE_BUTTON_6,
+      KeyEvent.KEYCODE_BUTTON_7,
+      KeyEvent.KEYCODE_BUTTON_8,
+      KeyEvent.KEYCODE_BUTTON_9,
+      KeyEvent.KEYCODE_BUTTON_10,
+      KeyEvent.KEYCODE_BUTTON_11,
+      KeyEvent.KEYCODE_BUTTON_12,
+      KeyEvent.KEYCODE_BUTTON_13,
+      KeyEvent.KEYCODE_BUTTON_14,
+      KeyEvent.KEYCODE_BUTTON_15,
+      KeyEvent.KEYCODE_BUTTON_16,
+    };
+    int[] masks = new int[]{
+      (1 << 0),   // A -> A
+      (1 << 1),   // B -> B
+      (1 << 2),   // X -> X
+      (1 << 3),   // Y -> Y
+      (1 << 4),   // BACK -> BACK
+      (1 << 6),   // MENU -> START
+      (1 << 5),   // MODE -> GUIDE
+      (1 << 6),   // START -> START
+      (1 << 7),   // THUMBL -> LEFTSTICK
+      (1 << 8),   // THUMBR -> RIGHTSTICK
+      (1 << 9),   // L1 -> LEFTSHOULDER
+      (1 << 10),  // R1 -> RIGHTSHOULDER
+      (1 << 11),  // DPAD_UP -> DPAD_UP
+      (1 << 12),  // DPAD_DOWN -> DPAD_DOWN
+      (1 << 13),  // DPAD_LEFT -> DPAD_LEFT
+      (1 << 14),  // DPAD_RIGHT -> DPAD_RIGHT
+      (1 << 4),   // SELECT -> BACK
+      (1 << 0),   // DPAD_CENTER -> A
+      (1 << 15),  // L2 -> ??
+      (1 << 16),  // R2 -> ??
+      (1 << 17),  // C -> ??
+      (1 << 18),  // Z -> ??
+      (1 << 20),  // 1 -> ??
+      (1 << 21),  // 2 -> ??
+      (1 << 22),  // 3 -> ??
+      (1 << 23),  // 4 -> ??
+      (1 << 24),  // 5 -> ??
+      (1 << 25),  // 6 -> ??
+      (1 << 26),  // 7 -> ??
+      (1 << 27),  // 8 -> ??
+      (1 << 28),  // 9 -> ??
+      (1 << 29),  // 10 -> ??
+      (1 << 30),  // 11 -> ??
+      (1 << 31),  // 12 -> ??
+      // We're out of room...
+      0xFFFFFFFF,  // 13 -> ??
+      0xFFFFFFFF,  // 14 -> ??
+      0xFFFFFFFF,  // 15 -> ??
+      0xFFFFFFFF,  // 16 -> ??
+    };
+    boolean[] has_keys = joystickDevice.hasKeys(keys);
+    for (int i = 0; i < keys.length; ++i) {
+      if (has_keys[i]) {
+        button_mask |= masks[i];
+      }
+    }
+    return button_mask;
+  }
+}
+
+class SDLHapticHandler_API26 extends SDLHapticHandler {
+  @Override
+  public void run(int device_id, float intensity, int length) {
+    SDLHaptic haptic = getHaptic(device_id);
+    if (haptic != null) {
+      Log.d("SDL", "Rtest: Vibe with intensity " + intensity + " for " + length);
+      if (intensity == 0.0f) {
+        stop(device_id);
+        return;
+      }
+
+      int vibeValue = Math.round(intensity * 255);
+
+      if (vibeValue > 255) {
+        vibeValue = 255;
+      }
+      if (vibeValue < 1) {
+        stop(device_id);
+        return;
+      }
+      try {
+        haptic.vib.vibrate(VibrationEffect.createOneShot(length, vibeValue));
+      } catch (Exception e) {
+        // Fall back to the generic method, which uses DEFAULT_AMPLITUDE, but works even if
+        // something went horribly wrong with the Android 8.0 APIs.
+        haptic.vib.vibrate(length);
+      }
+    }
+  }
+}
+
+class SDLHapticHandler {
+
+  private final ArrayList<SDLHaptic> mHaptics;
+
+  public SDLHapticHandler() {
+    mHaptics = new ArrayList<SDLHaptic>();
+  }
+
+  public void run(int device_id, float intensity, int length) {
+    SDLHaptic haptic = getHaptic(device_id);
+    if (haptic != null) {
+      haptic.vib.vibrate(length);
+    }
+  }
+
+  public void stop(int device_id) {
+    SDLHaptic haptic = getHaptic(device_id);
+    if (haptic != null) {
+      haptic.vib.cancel();
+    }
+  }
+
+  public void pollHapticDevices() {
+
+    final int deviceId_VIBRATOR_SERVICE = 999999;
+    boolean hasVibratorService = false;
+
+    int[] deviceIds = InputDevice.getDeviceIds();
+    // It helps processing the device ids in reverse order
+    // For example, in the case of the XBox 360 wireless dongle,
+    // so the first controller seen by SDL matches what the receiver
+    // considers to be the first controller
+
+    for (int i = deviceIds.length - 1; i > -1; i--) {
+      SDLHaptic haptic = getHaptic(deviceIds[i]);
+      if (haptic == null) {
+        InputDevice device = InputDevice.getDevice(deviceIds[i]);
+        Vibrator vib = device.getVibrator();
+        if (vib != null) {
+          if (vib.hasVibrator()) {
+            haptic = new SDLHaptic();
+            haptic.device_id = deviceIds[i];
+            haptic.name = device.getName();
+            haptic.vib = vib;
+            mHaptics.add(haptic);
+            SDLControllerManager.nativeAddHaptic(haptic.device_id, haptic.name);
+          }
+        }
+      }
+    }
+
+    /* Check VIBRATOR_SERVICE */
+    Vibrator vib = (Vibrator) SDL.getContext().getSystemService(Context.VIBRATOR_SERVICE);
+    if (vib != null) {
+      hasVibratorService = vib.hasVibrator();
+
+      if (hasVibratorService) {
+        SDLHaptic haptic = getHaptic(deviceId_VIBRATOR_SERVICE);
+        if (haptic == null) {
+          haptic = new SDLHaptic();
+          haptic.device_id = deviceId_VIBRATOR_SERVICE;
+          haptic.name = "VIBRATOR_SERVICE";
+          haptic.vib = vib;
+          mHaptics.add(haptic);
+          SDLControllerManager.nativeAddHaptic(haptic.device_id, haptic.name);
+        }
+      }
+    }
+
+    /* Check removed devices */
+    ArrayList<Integer> removedDevices = null;
+    for (SDLHaptic haptic : mHaptics) {
+      int device_id = haptic.device_id;
+      int i;
+      for (i = 0; i < deviceIds.length; i++) {
+        if (device_id == deviceIds[i]) break;
+      }
+
+      if (device_id != deviceId_VIBRATOR_SERVICE || !hasVibratorService) {
+        if (i == deviceIds.length) {
+          if (removedDevices == null) {
+            removedDevices = new ArrayList<Integer>();
+          }
+          removedDevices.add(device_id);
+        }
+      }  // else: don't remove the vibrator if it is still present
+    }
+
+    if (removedDevices != null) {
+      for (int device_id : removedDevices) {
+        SDLControllerManager.nativeRemoveHaptic(device_id);
+        for (int i = 0; i < mHaptics.size(); i++) {
+          if (mHaptics.get(i).device_id == device_id) {
+            mHaptics.remove(i);
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  protected SDLHaptic getHaptic(int device_id) {
+    for (SDLHaptic haptic : mHaptics) {
+      if (haptic.device_id == device_id) {
+        return haptic;
+      }
+    }
+    return null;
+  }
+
+  static class SDLHaptic {
+    public int device_id;
+    public String name;
+    public Vibrator vib;
+  }
+}
+
+class SDLGenericMotionListener_API12 implements View.OnGenericMotionListener {
+  // Generic Motion (mouse hover, joystick...) events go here
+  @Override
+  public boolean onGenericMotion(View v, MotionEvent event) {
+    float x, y;
+    int action;
+
+    switch (event.getSource()) {
+      case InputDevice.SOURCE_JOYSTICK:
+        return SDLControllerManager.handleJoystickMotionEvent(event);
+
+      case InputDevice.SOURCE_MOUSE:
+        action = event.getActionMasked();
+        switch (action) {
+          case MotionEvent.ACTION_SCROLL:
+            x = event.getAxisValue(MotionEvent.AXIS_HSCROLL, 0);
+            y = event.getAxisValue(MotionEvent.AXIS_VSCROLL, 0);
+            SDLActivity.onNativeMouse(0, action, x, y, false);
+            return true;
+
+          case MotionEvent.ACTION_HOVER_MOVE:
+            x = event.getX(0);
+            y = event.getY(0);
+
+            SDLActivity.onNativeMouse(0, action, x, y, false);
+            return true;
+
+          default:
+            break;
+        }
+        break;
+
+      default:
+        break;
+    }
+
+    // Event was not managed
+    return false;
+  }
+
+  public boolean supportsRelativeMouse() {
+    return false;
+  }
+
+  public boolean inRelativeMode() {
+    return false;
+  }
+
+  public boolean setRelativeMouseEnabled(boolean enabled) {
+    return false;
+  }
+
+  public void reclaimRelativeMouseModeIfNeeded() {
+
+  }
+
+  public float getEventX(MotionEvent event) {
+    return event.getX(0);
+  }
+
+  public float getEventY(MotionEvent event) {
+    return event.getY(0);
+  }
+
+}
+
+class SDLGenericMotionListener_API24 extends SDLGenericMotionListener_API12 {
+  // Generic Motion (mouse hover, joystick...) events go here
+
+  private boolean mRelativeModeEnabled;
+
+  @Override
+  public boolean onGenericMotion(View v, MotionEvent event) {
+
+    // Handle relative mouse mode
+    if (mRelativeModeEnabled) {
+      if (event.getSource() == InputDevice.SOURCE_MOUSE) {
+        int action = event.getActionMasked();
+        if (action == MotionEvent.ACTION_HOVER_MOVE) {
+          float x = event.getAxisValue(MotionEvent.AXIS_RELATIVE_X);
+          float y = event.getAxisValue(MotionEvent.AXIS_RELATIVE_Y);
+          SDLActivity.onNativeMouse(0, action, x, y, true);
+          return true;
+        }
+      }
+    }
+
+    // Event was not managed, call SDLGenericMotionListener_API12 method
+    return super.onGenericMotion(v, event);
+  }
+
+  @Override
+  public boolean supportsRelativeMouse() {
+    return true;
+  }
+
+  @Override
+  public boolean inRelativeMode() {
+    return mRelativeModeEnabled;
+  }
+
+  @Override
+  public boolean setRelativeMouseEnabled(boolean enabled) {
+    mRelativeModeEnabled = enabled;
+    return true;
+  }
+
+  @Override
+  public float getEventX(MotionEvent event) {
+    if (mRelativeModeEnabled) {
+      return event.getAxisValue(MotionEvent.AXIS_RELATIVE_X);
+    } else {
+      return event.getX(0);
+    }
+  }
+
+  @Override
+  public float getEventY(MotionEvent event) {
+    if (mRelativeModeEnabled) {
+      return event.getAxisValue(MotionEvent.AXIS_RELATIVE_Y);
+    } else {
+      return event.getY(0);
+    }
+  }
+}
+
+class SDLGenericMotionListener_API26 extends SDLGenericMotionListener_API24 {
+  // Generic Motion (mouse hover, joystick...) events go here
+  private boolean mRelativeModeEnabled;
+
+  @Override
+  public boolean onGenericMotion(View v, MotionEvent event) {
+    float x, y;
+    int action;
+
+    switch (event.getSource()) {
+      case InputDevice.SOURCE_JOYSTICK:
+        return SDLControllerManager.handleJoystickMotionEvent(event);
+
+      case InputDevice.SOURCE_MOUSE:
+        // DeX desktop mouse cursor is a separate non-standard input type.
+      case InputDevice.SOURCE_MOUSE | InputDevice.SOURCE_TOUCHSCREEN:
+        action = event.getActionMasked();
+        switch (action) {
+          case MotionEvent.ACTION_SCROLL:
+            x = event.getAxisValue(MotionEvent.AXIS_HSCROLL, 0);
+            y = event.getAxisValue(MotionEvent.AXIS_VSCROLL, 0);
+            SDLActivity.onNativeMouse(0, action, x, y, false);
+            return true;
+
+          case MotionEvent.ACTION_HOVER_MOVE:
+            x = event.getX(0);
+            y = event.getY(0);
+            SDLActivity.onNativeMouse(0, action, x, y, false);
+            return true;
+
+          default:
+            break;
+        }
+        break;
+
+      case InputDevice.SOURCE_MOUSE_RELATIVE:
+        action = event.getActionMasked();
+        switch (action) {
+          case MotionEvent.ACTION_SCROLL:
+            x = event.getAxisValue(MotionEvent.AXIS_HSCROLL, 0);
+            y = event.getAxisValue(MotionEvent.AXIS_VSCROLL, 0);
+            SDLActivity.onNativeMouse(0, action, x, y, false);
+            return true;
+
+          case MotionEvent.ACTION_HOVER_MOVE:
+            x = event.getX(0);
+            y = event.getY(0);
+            SDLActivity.onNativeMouse(0, action, x, y, true);
+            return true;
+
+          default:
+            break;
+        }
+        break;
+
+      default:
+        break;
+    }
+
+    // Event was not managed
+    return false;
+  }
+
+  @Override
+  public boolean supportsRelativeMouse() {
+    return (!SDLActivity.isDeXMode() || Build.VERSION.SDK_INT >= 27 /* Android 8.1 (O_MR1) */);
+  }
+
+  @Override
+  public boolean inRelativeMode() {
+    return mRelativeModeEnabled;
+  }
+
+  @Override
+  public boolean setRelativeMouseEnabled(boolean enabled) {
+    if (!SDLActivity.isDeXMode() || Build.VERSION.SDK_INT >= 27 /* Android 8.1 (O_MR1) */) {
+      if (enabled) {
+        SDLActivity.getContentView().requestPointerCapture();
+      } else {
+        SDLActivity.getContentView().releasePointerCapture();
+      }
+      mRelativeModeEnabled = enabled;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  @Override
+  public void reclaimRelativeMouseModeIfNeeded() {
+    if (mRelativeModeEnabled && !SDLActivity.isDeXMode()) {
+      SDLActivity.getContentView().requestPointerCapture();
+    }
+  }
+
+  @Override
+  public float getEventX(MotionEvent event) {
+    // Relative mouse in capture mode will only have relative for X/Y
+    return event.getX(0);
+  }
+
+  @Override
+  public float getEventY(MotionEvent event) {
+    // Relative mouse in capture mode will only have relative for X/Y
+    return event.getY(0);
+  }
+}
diff --git a/android/src/main/java/org/libsdl/app/SDLSurface.java b/android/src/main/java/org/libsdl/app/SDLSurface.java
new file mode 100644
index 000000000..0208c78d1
--- /dev/null
+++ b/android/src/main/java/org/libsdl/app/SDLSurface.java
@@ -0,0 +1,401 @@
+package org.libsdl.app;
+
+
+import android.content.Context;
+import android.content.pm.ActivityInfo;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.Build;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.view.Display;
+import android.view.InputDevice;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.Surface;
+import android.view.SurfaceHolder;
+import android.view.SurfaceView;
+import android.view.View;
+import android.view.WindowManager;
+
+
+/**
+ * SDLSurface. This is what we draw on, so we need to know when it's created
+ * in order to do anything useful.
+ * <p>
+ * Because of this, that's where we set up the SDL thread
+ */
+public class SDLSurface extends SurfaceView implements SurfaceHolder.Callback,
+  View.OnKeyListener, View.OnTouchListener, SensorEventListener {
+
+  // Is SurfaceView ready for rendering
+  public boolean mIsSurfaceReady;
+  // Sensors
+  protected SensorManager mSensorManager;
+  protected Display mDisplay;
+  // Keep track of the surface size to normalize touch events
+  protected float mWidth, mHeight;
+
+  // Startup
+  public SDLSurface(Context context) {
+    super(context);
+    getHolder().addCallback(this);
+
+    setFocusable(true);
+    setFocusableInTouchMode(true);
+    requestFocus();
+    setOnKeyListener(this);
+    setOnTouchListener(this);
+
+    mDisplay = ((WindowManager) context.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
+    mSensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
+
+    setOnGenericMotionListener(SDLActivity.getMotionListener());
+
+    // Some arbitrary defaults to avoid a potential division by zero
+    mWidth = 1.0f;
+    mHeight = 1.0f;
+
+    mIsSurfaceReady = false;
+  }
+
+  public void handlePause() {
+    enableSensor(Sensor.TYPE_ACCELEROMETER, false);
+  }
+
+  public void handleResume() {
+    setFocusable(true);
+    setFocusableInTouchMode(true);
+    requestFocus();
+    setOnKeyListener(this);
+    setOnTouchListener(this);
+    enableSensor(Sensor.TYPE_ACCELEROMETER, true);
+  }
+
+  public Surface getNativeSurface() {
+    return getHolder().getSurface();
+  }
+
+  // Called when we have a valid drawing surface
+  @Override
+  public void surfaceCreated(SurfaceHolder holder) {
+    Log.v("SDL", "surfaceCreated()");
+    SDLActivity.onNativeSurfaceCreated();
+  }
+
+  // Called when we lose the surface
+  @Override
+  public void surfaceDestroyed(SurfaceHolder holder) {
+    Log.v("SDL", "surfaceDestroyed()");
+
+    // Transition to pause, if needed
+    SDLActivity.mNextNativeState = SDLActivity.NativeState.PAUSED;
+    SDLActivity.handleNativeState();
+
+    mIsSurfaceReady = false;
+    SDLActivity.onNativeSurfaceDestroyed();
+  }
+
+  // Called when the surface is resized
+  @Override
+  public void surfaceChanged(SurfaceHolder holder,
+                             int format, int width, int height) {
+    Log.v("SDL", "surfaceChanged()");
+
+    if (SDLActivity.mSingleton == null) {
+      return;
+    }
+
+    mWidth = width;
+    mHeight = height;
+    int nDeviceWidth = width;
+    int nDeviceHeight = height;
+    try {
+      if (Build.VERSION.SDK_INT >= 17 /* Android 4.2 (JELLY_BEAN_MR1) */) {
+        DisplayMetrics realMetrics = new DisplayMetrics();
+        mDisplay.getRealMetrics(realMetrics);
+        nDeviceWidth = realMetrics.widthPixels;
+        nDeviceHeight = realMetrics.heightPixels;
+      }
+    } catch (Exception ignored) {
+    }
+
+    synchronized (SDLActivity.getContext()) {
+      // In case we're waiting on a size change after going fullscreen, send a notification.
+      SDLActivity.getContext().notifyAll();
+    }
+
+    Log.v("SDL", "Window size: " + width + "x" + height);
+    Log.v("SDL", "Device size: " + nDeviceWidth + "x" + nDeviceHeight);
+    SDLActivity.nativeSetScreenResolution(width, height, nDeviceWidth, nDeviceHeight, mDisplay.getRefreshRate());
+    SDLActivity.onNativeResize();
+
+    // Prevent a screen distortion glitch,
+    // for instance when the device is in Landscape and a Portrait App is resumed.
+    boolean skip = false;
+    int requestedOrientation = SDLActivity.mSingleton.getRequestedOrientation();
+
+    if (requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_PORTRAIT || requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT) {
+      if (mWidth > mHeight) {
+        skip = true;
+      }
+    } else if (requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE || requestedOrientation == ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE) {
+      if (mWidth < mHeight) {
+        skip = true;
+      }
+    }
+
+    // Special Patch for Square Resolution: Black Berry Passport
+    if (skip) {
+      double min = Math.min(mWidth, mHeight);
+      double max = Math.max(mWidth, mHeight);
+
+      if (max / min < 1.20) {
+        Log.v("SDL", "Don't skip on such aspect-ratio. Could be a square resolution.");
+        skip = false;
+      }
+    }
+
+    // Don't skip in MultiWindow.
+    if (skip) {
+      if (Build.VERSION.SDK_INT >= 24 /* Android 7.0 (N) */) {
+        if (SDLActivity.mSingleton.isInMultiWindowMode()) {
+          Log.v("SDL", "Don't skip in Multi-Window");
+          skip = false;
+        }
+      }
+    }
+
+    if (skip) {
+      Log.v("SDL", "Skip .. Surface is not ready.");
+      mIsSurfaceReady = false;
+      return;
+    }
+
+    /* If the surface has been previously destroyed by onNativeSurfaceDestroyed, recreate it here */
+    SDLActivity.onNativeSurfaceChanged();
+
+    /* Surface is ready */
+    mIsSurfaceReady = true;
+
+    SDLActivity.mNextNativeState = SDLActivity.NativeState.RESUMED;
+    SDLActivity.handleNativeState();
+  }
+
+  // Key events
+  @Override
+  public boolean onKey(View v, int keyCode, KeyEvent event) {
+    return SDLActivity.handleKeyEvent(v, keyCode, event, null);
+  }
+
+  // Touch events
+  @Override
+  public boolean onTouch(View v, MotionEvent event) {
+    /* Ref: http://developer.android.com/training/gestures/multi.html */
+    int touchDevId = event.getDeviceId();
+    final int pointerCount = event.getPointerCount();
+    int action = event.getActionMasked();
+    int pointerFingerId;
+    int i = -1;
+    float x, y, p;
+
+    /*
+     * Prevent id to be -1, since it's used in SDL internal for synthetic events
+     * Appears when using Android emulator, eg:
+     *  adb shell input mouse tap 100 100
+     *  adb shell input touchscreen tap 100 100
+     */
+    if (touchDevId < 0) {
+      touchDevId -= 1;
+    }
+
+    // 12290 = Samsung DeX mode desktop mouse
+    // 12290 = 0x3002 = 0x2002 | 0x1002 = SOURCE_MOUSE | SOURCE_TOUCHSCREEN
+    // 0x2   = SOURCE_CLASS_POINTER
+    if (event.getSource() == InputDevice.SOURCE_MOUSE || event.getSource() == (InputDevice.SOURCE_MOUSE | InputDevice.SOURCE_TOUCHSCREEN)) {
+      int mouseButton = 1;
+      try {
+        Object object = event.getClass().getMethod("getButtonState").invoke(event);
+        if (object != null) {
+          mouseButton = (Integer) object;
+        }
+      } catch (Exception ignored) {
+      }
+
+      // We need to check if we're in relative mouse mode and get the axis offset rather than the x/y values
+      // if we are.  We'll leverage our existing mouse motion listener
+      SDLGenericMotionListener_API12 motionListener = SDLActivity.getMotionListener();
+      x = motionListener.getEventX(event);
+      y = motionListener.getEventY(event);
+
+      SDLActivity.onNativeMouse(mouseButton, action, x, y, motionListener.inRelativeMode());
+    } else {
+      switch (action) {
+        case MotionEvent.ACTION_MOVE:
+          for (i = 0; i < pointerCount; i++) {
+            pointerFingerId = event.getPointerId(i);
+            x = event.getX(i) / mWidth;
+            y = event.getY(i) / mHeight;
+            p = event.getPressure(i);
+            if (p > 1.0f) {
+              // may be larger than 1.0f on some devices
+              // see the documentation of getPressure(i)
+              p = 1.0f;
+            }
+            SDLActivity.onNativeTouch(touchDevId, pointerFingerId, action, x, y, p);
+          }
+          break;
+
+        case MotionEvent.ACTION_UP:
+        case MotionEvent.ACTION_DOWN:
+          // Primary pointer up/down, the index is always zero
+          i = 0;
+          /* fallthrough */
+        case MotionEvent.ACTION_POINTER_UP:
+        case MotionEvent.ACTION_POINTER_DOWN:
+          // Non primary pointer up/down
+          if (i == -1) {
+            i = event.getActionIndex();
+          }
+
+          pointerFingerId = event.getPointerId(i);
+          x = event.getX(i) / mWidth;
+          y = event.getY(i) / mHeight;
+          p = event.getPressure(i);
+          if (p > 1.0f) {
+            // may be larger than 1.0f on some devices
+            // see the documentation of getPressure(i)
+            p = 1.0f;
+          }
+          SDLActivity.onNativeTouch(touchDevId, pointerFingerId, action, x, y, p);
+          break;
+
+        case MotionEvent.ACTION_CANCEL:
+          for (i = 0; i < pointerCount; i++) {
+            pointerFingerId = event.getPointerId(i);
+            x = event.getX(i) / mWidth;
+            y = event.getY(i) / mHeight;
+            p = event.getPressure(i);
+            if (p > 1.0f) {
+              // may be larger than 1.0f on some devices
+              // see the documentation of getPressure(i)
+              p = 1.0f;
+            }
+            SDLActivity.onNativeTouch(touchDevId, pointerFingerId, MotionEvent.ACTION_UP, x, y, p);
+          }
+          break;
+
+        default:
+          break;
+      }
+    }
+
+    return true;
+  }
+
+  // Sensor events
+  public void enableSensor(int sensortype, boolean enabled) {
+    // TODO: This uses getDefaultSensor - what if we have >1 accels?
+    if (enabled) {
+      mSensorManager.registerListener(this,
+        mSensorManager.getDefaultSensor(sensortype),
+        SensorManager.SENSOR_DELAY_GAME, null);
+    } else {
+      mSensorManager.unregisterListener(this,
+        mSensorManager.getDefaultSensor(sensortype));
+    }
+  }
+
+  @Override
+  public void onAccuracyChanged(Sensor sensor, int accuracy) {
+    // TODO
+  }
+
+  @Override
+  public void onSensorChanged(SensorEvent event) {
+    if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
+
+      // Since we may have an orientation set, we won't receive onConfigurationChanged events.
+      // We thus should check here.
+      int newOrientation;
+
+      float x, y;
+      switch (mDisplay.getRotation()) {
+        case Surface.ROTATION_90:
+          x = -event.values[1];
+          y = event.values[0];
+          newOrientation = SDLActivity.SDL_ORIENTATION_LANDSCAPE;
+          break;
+        case Surface.ROTATION_270:
+          x = event.values[1];
+          y = -event.values[0];
+          newOrientation = SDLActivity.SDL_ORIENTATION_LANDSCAPE_FLIPPED;
+          break;
+        case Surface.ROTATION_180:
+          x = -event.values[0];
+          y = -event.values[1];
+          newOrientation = SDLActivity.SDL_ORIENTATION_PORTRAIT_FLIPPED;
+          break;
+        case Surface.ROTATION_0:
+        default:
+          x = event.values[0];
+          y = event.values[1];
+          newOrientation = SDLActivity.SDL_ORIENTATION_PORTRAIT;
+          break;
+      }
+
+      if (newOrientation != SDLActivity.mCurrentOrientation) {
+        SDLActivity.mCurrentOrientation = newOrientation;
+        SDLActivity.onNativeOrientationChanged(newOrientation);
+      }
+
+      SDLActivity.onNativeAccel(-x / SensorManager.GRAVITY_EARTH,
+        y / SensorManager.GRAVITY_EARTH,
+        event.values[2] / SensorManager.GRAVITY_EARTH);
+
+
+    }
+  }
+
+  // Captured pointer events for API 26.
+  public boolean onCapturedPointerEvent(MotionEvent event) {
+    int action = event.getActionMasked();
+
+    float x, y;
+    switch (action) {
+      case MotionEvent.ACTION_SCROLL:
+        x = event.getAxisValue(MotionEvent.AXIS_HSCROLL, 0);
+        y = event.getAxisValue(MotionEvent.AXIS_VSCROLL, 0);
+        SDLActivity.onNativeMouse(0, action, x, y, false);
+        return true;
+
+      case MotionEvent.ACTION_HOVER_MOVE:
+      case MotionEvent.ACTION_MOVE:
+        x = event.getX(0);
+        y = event.getY(0);
+        SDLActivity.onNativeMouse(0, action, x, y, true);
+        return true;
+
+      case MotionEvent.ACTION_BUTTON_PRESS:
+      case MotionEvent.ACTION_BUTTON_RELEASE:
+
+        // Change our action value to what SDL's code expects.
+        if (action == MotionEvent.ACTION_BUTTON_PRESS) {
+          action = MotionEvent.ACTION_DOWN;
+        } else { /* MotionEvent.ACTION_BUTTON_RELEASE */
+          action = MotionEvent.ACTION_UP;
+        }
+
+        x = event.getX(0);
+        y = event.getY(0);
+        int button = event.getButtonState();
+
+        SDLActivity.onNativeMouse(button, action, x, y, true);
+        return true;
+    }
+
+    return false;
+  }
+}
diff --git a/android/src/main/res/layout/game_data_layout_activity.xml b/android/src/main/res/layout/game_data_layout_activity.xml
new file mode 100644
index 000000000..018ae4db2
--- /dev/null
+++ b/android/src/main/res/layout/game_data_layout_activity.xml
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="match_parent"
+  android:layout_height="match_parent">
+
+  <TextView
+    android:layout_width="wrap_content"
+    android:layout_height="wrap_content"
+    android:layout_gravity="center"
+    android:text="Game Data Upload"
+    android:textSize="36sp" />
+</FrameLayout>
\ No newline at end of file
diff --git a/android/src/main/res/mipmap-xxxhdpi/ic_launcher.webp b/android/src/main/res/mipmap-xxxhdpi/ic_launcher.webp
new file mode 100644
index 0000000000000000000000000000000000000000..01d9a4e1a79f39b2bd966bc616db7209719b1d6a
GIT binary patch
literal 2020
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
Cfw6M{

literal 0
HcmV?d00001

diff --git a/android/src/main/res/values/colors.xml b/android/src/main/res/values/colors.xml
new file mode 100644
index 000000000..5a077b3a7
--- /dev/null
+++ b/android/src/main/res/values/colors.xml
@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <color name="colorPrimary">#3F51B5</color>
+  <color name="colorPrimaryDark">#303F9F</color>
+  <color name="colorAccent">#FF4081</color>
+</resources>
diff --git a/android/src/main/res/values/strings.xml b/android/src/main/res/values/strings.xml
new file mode 100644
index 000000000..80c4f1e10
--- /dev/null
+++ b/android/src/main/res/values/strings.xml
@@ -0,0 +1,3 @@
+<resources>
+  <string name="app_name">Descent 3</string>
+</resources>
diff --git a/android/src/main/res/values/styles.xml b/android/src/main/res/values/styles.xml
new file mode 100644
index 000000000..8fa05a01e
--- /dev/null
+++ b/android/src/main/res/values/styles.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <!-- Base application theme. -->
+  <style name="AppTheme" parent="android:Theme.NoTitleBar.Fullscreen">
+    <!-- Customize your theme here. -->
+  </style>
+</resources>
diff --git a/build.gradle b/build.gradle
new file mode 100644
index 000000000..3ce3cac23
--- /dev/null
+++ b/build.gradle
@@ -0,0 +1,25 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+
+buildscript {
+    repositories {
+        mavenCentral()
+        google()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.5.0'
+
+        // NOTE: Do not place your application dependencies here; they belong
+        // in the individual module build.gradle files
+    }
+}
+
+allprojects {
+    repositories {
+        mavenCentral()
+        google()
+    }
+}
+
+task clean(type: Delete) {
+    delete rootProject.buildDir
+}
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 000000000..aac7c9b46
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,17 @@
+# Project-wide Gradle settings.
+
+# IDE (e.g. Android Studio) users:
+# Gradle settings configured through the IDE *will override*
+# any settings specified in this file.
+
+# For more details on how to configure your build environment visit
+# http://www.gradle.org/docs/current/userguide/build_environment.html
+
+# Specifies the JVM arguments used for the daemon process.
+# The setting is particularly useful for tweaking memory settings.
+org.gradle.jvmargs=-Xmx1536m
+
+# When configured, Gradle will run in incubating parallel mode.
+# This option should only be used with decoupled projects. More details, visit
+# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
+# org.gradle.parallel=true
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
new file mode 100644
index 0000000000000000000000000000000000000000..2b338a935b508eb6286ed4b84a91176ee5fb93c5
GIT binary patch
literal 54213
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
W0pC&I?SueJAtDe^1>pYz0sTMJrJ5N4

literal 0
HcmV?d00001

diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
new file mode 100644
index 000000000..9d17becdb
--- /dev/null
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -0,0 +1,6 @@
+#Thu Nov 11 18:20:34 PST 2021
+distributionBase=GRADLE_USER_HOME
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-bin.zip
+distributionPath=wrapper/dists
+zipStorePath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
diff --git a/gradlew b/gradlew
new file mode 100755
index 000000000..3427607f4
--- /dev/null
+++ b/gradlew
@@ -0,0 +1,160 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|grep -E -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|grep -E -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
diff --git a/gradlew.bat b/gradlew.bat
new file mode 100644
index 000000000..8a0b282aa
--- /dev/null
+++ b/gradlew.bat
@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega
diff --git a/settings.gradle b/settings.gradle
new file mode 100644
index 000000000..d69713c24
--- /dev/null
+++ b/settings.gradle
@@ -0,0 +1 @@
+include ':android'

From 28983f99bc4cf7b881c20603d4b574381a7f7550 Mon Sep 17 00:00:00 2001
From: Chris Sarbora <tophyr@gmail.com>
Date: Wed, 1 Jan 2025 14:16:29 -0600
Subject: [PATCH 08/10] Extract gamedata knowledge into dedicated common
 methods

---
 .../java/com/descent3/droid/Constants.java    | 24 +++++++++++++++++++
 .../droid/GameDataUploadActivity.java         |  2 +-
 .../java/com/descent3/droid/MainActivity.java |  6 ++---
 3 files changed, 28 insertions(+), 4 deletions(-)
 create mode 100644 android/src/main/java/com/descent3/droid/Constants.java

diff --git a/android/src/main/java/com/descent3/droid/Constants.java b/android/src/main/java/com/descent3/droid/Constants.java
new file mode 100644
index 000000000..fc1066f67
--- /dev/null
+++ b/android/src/main/java/com/descent3/droid/Constants.java
@@ -0,0 +1,24 @@
+package com.descent3.droid;
+
+import android.content.Context;
+
+import java.io.File;
+import java.nio.file.Path;
+
+public class Constants {
+  private static Path getGameDataDirFrom(File base) {
+    return base.toPath().resolve("gamedata");
+  }
+
+  public static Path getCacheGameDataDir(Context ctx) {
+    return getGameDataDirFrom(ctx.getCacheDir());
+  }
+
+  public static Path getFileGameDataDir(Context ctx) {
+    return getGameDataDirFrom(ctx.getFilesDir());
+  }
+
+  public static boolean isGameDataPresent(Context ctx) {
+    return getCacheGameDataDir(ctx).resolve("d3.hog").toFile().exists();
+  }
+}
diff --git a/android/src/main/java/com/descent3/droid/GameDataUploadActivity.java b/android/src/main/java/com/descent3/droid/GameDataUploadActivity.java
index 0011d52fb..c59f4b03f 100644
--- a/android/src/main/java/com/descent3/droid/GameDataUploadActivity.java
+++ b/android/src/main/java/com/descent3/droid/GameDataUploadActivity.java
@@ -34,7 +34,7 @@ protected void onCreate(Bundle savedInstanceState) {
 
     mServer = new GameDataHttpServer(
       getAssets(),
-      getCacheDir().toPath().resolve("gamedata"),
+      Constants.getCacheGameDataDir(this),
       () -> {
         // TODO: there's gonna be a race here; should explicitly have the Success html trigger this?
         startActivity(new Intent(this, MainActivity.class));
diff --git a/android/src/main/java/com/descent3/droid/MainActivity.java b/android/src/main/java/com/descent3/droid/MainActivity.java
index bc3aee61b..419c8e0e2 100644
--- a/android/src/main/java/com/descent3/droid/MainActivity.java
+++ b/android/src/main/java/com/descent3/droid/MainActivity.java
@@ -22,15 +22,15 @@ protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
 
     try {
-      mFilesGameData = getFilesDir().toPath().resolve("gamedata");
+      mFilesGameData = Constants.getFileGameDataDir(this);
       Files.createDirectories(mFilesGameData);
-      mCacheGameData = getCacheDir().toPath().resolve("gamedata");
+      mCacheGameData = Constants.getCacheGameDataDir(this);
       mTempDir = Files.createTempDirectory("d3");
     } catch (IOException ex) {
       throw new RuntimeException(ex);
     }
 
-    if (!mCacheGameData.resolve("d3.hog").toFile().exists()) {
+    if (!Constants.isGameDataPresent(this)) {
       startActivity(new Intent(this, GameDataUploadActivity.class));
       finish();
     }

From f992e0ad66ae7ee6cf1d763ba9510b00a35eab28 Mon Sep 17 00:00:00 2001
From: Chris Sarbora <tophyr@gmail.com>
Date: Wed, 1 Jan 2025 23:34:54 -0600
Subject: [PATCH 09/10] Add instructions to Gamedata Upload screen

---
 android/src/main/AndroidManifest.xml          |  3 +-
 .../droid/GameDataUploadActivity.java         | 64 ++++++++++++++++++-
 .../res/layout/game_data_layout_activity.xml  | 30 +++++++--
 android/src/main/res/values/strings.xml       |  3 +
 4 files changed, 91 insertions(+), 9 deletions(-)

diff --git a/android/src/main/AndroidManifest.xml b/android/src/main/AndroidManifest.xml
index 3ca93d8ab..f51bfeb04 100644
--- a/android/src/main/AndroidManifest.xml
+++ b/android/src/main/AndroidManifest.xml
@@ -45,7 +45,8 @@
   <!-- <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" /> -->
 
   <!-- Allow access to the vibrator -->
-  <uses-permission android:name="android.permission.VIBRATE" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.VIBRATE" />
   <uses-permission android:name="android.permission.INTERNET" />
 
   <!-- Create a Java class extending SDLActivity and place it in a
diff --git a/android/src/main/java/com/descent3/droid/GameDataUploadActivity.java b/android/src/main/java/com/descent3/droid/GameDataUploadActivity.java
index c59f4b03f..bd8e4d182 100644
--- a/android/src/main/java/com/descent3/droid/GameDataUploadActivity.java
+++ b/android/src/main/java/com/descent3/droid/GameDataUploadActivity.java
@@ -9,28 +9,77 @@
 import android.app.Activity;
 import android.content.Intent;
 import android.content.res.AssetManager;
+import android.net.ConnectivityManager;
+import android.net.ConnectivityManager.NetworkCallback;
+import android.net.LinkAddress;
+import android.net.LinkProperties;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkRequest;
 import android.os.Bundle;
+import android.os.PowerManager;
 import android.text.Html;
 import android.util.Log;
+import android.widget.TextView;
 
 import java.io.IOException;
 import java.io.OutputStream;
+import java.net.InetAddress;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import fi.iki.elonen.NanoHTTPD;
 
 public class GameDataUploadActivity extends Activity {
   private GameDataHttpServer mServer;
+  private TextView mHttpServerAddresses;
+
+  private final NetworkCallback mNetworkCallback = new NetworkCallback() {
+    private final HashMap<Network, LinkProperties> mLinks = new HashMap<>();
+
+    @Override
+    public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
+      mLinks.put(network, linkProperties);
+      updateAddresses();
+    }
+
+    @Override
+    public void onLost(Network network) {
+      mLinks.remove(network);
+      updateAddresses();
+    }
+
+    private void updateAddresses() {
+      Set<InetAddress> addresses =
+        mLinks.values().stream()
+          .map(LinkProperties::getLinkAddresses)
+          .flatMap(List::stream)
+          .map(LinkAddress::getAddress)
+          .collect(Collectors.toSet());
+      if (addresses.isEmpty()) {
+        mHttpServerAddresses.setText(R.string.network_unavailable);
+      } else {
+        mHttpServerAddresses.setText(addresses.stream()
+          .map(InetAddress::getHostAddress)
+          .map(s -> "http://" + s + ":" + mServer.getListeningPort() + "/")
+          .collect(Collectors.joining("\n")));
+      }
+    }
+  };
 
   @Override
   protected void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
+    setContentView(R.layout.game_data_layout_activity);
+    mHttpServerAddresses = findViewById(R.id.game_data_http_server);
 
     mServer = new GameDataHttpServer(
       getAssets(),
@@ -40,23 +89,34 @@ protected void onCreate(Bundle savedInstanceState) {
         startActivity(new Intent(this, MainActivity.class));
         finish();
       });
-
-    setContentView(R.layout.game_data_layout_activity);
   }
 
   @Override
   protected void onStart() {
     super.onStart();
+
+    mHttpServerAddresses.setText(R.string.network_unavailable);
+
     try {
       mServer.start();
     } catch (IOException e) {
       throw new RuntimeException(e);
     }
+
+    getSystemService(ConnectivityManager.class).registerNetworkCallback(
+      new NetworkRequest.Builder()
+        .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)
+        .addTransportType(NetworkCapabilities.TRANSPORT_ETHERNET)
+        .addTransportType(NetworkCapabilities.TRANSPORT_WIFI_AWARE)
+        .build(),
+      mNetworkCallback);
   }
 
   @Override
   protected void onStop() {
     super.onStop();
+
+    getSystemService(ConnectivityManager.class).unregisterNetworkCallback(mNetworkCallback);
     mServer.stop();
   }
 
diff --git a/android/src/main/res/layout/game_data_layout_activity.xml b/android/src/main/res/layout/game_data_layout_activity.xml
index 018ae4db2..6b939364a 100644
--- a/android/src/main/res/layout/game_data_layout_activity.xml
+++ b/android/src/main/res/layout/game_data_layout_activity.xml
@@ -1,12 +1,30 @@
 <?xml version="1.0" encoding="utf-8"?>
-<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_width="match_parent"
-  android:layout_height="match_parent">
+  android:layout_height="match_parent"
+  android:keepScreenOn="true"
+  android:gravity="center"
+  android:orientation="vertical">
 
   <TextView
-    android:layout_width="wrap_content"
+    android:layout_width="match_parent"
     android:layout_height="wrap_content"
-    android:layout_gravity="center"
-    android:text="Game Data Upload"
+    android:gravity="center"
+    android:text="@string/game_data_upload"
     android:textSize="36sp" />
-</FrameLayout>
\ No newline at end of file
+
+  <TextView
+    android:id="@+id/game_data_http_server"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:gravity="center"
+    android:text="@string/network_unavailable"
+    android:textSize="20sp"/>
+
+  <TextView
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:gravity="center"
+    android:text="@string/upload_instructions"/>
+
+</LinearLayout>
\ No newline at end of file
diff --git a/android/src/main/res/values/strings.xml b/android/src/main/res/values/strings.xml
index 80c4f1e10..f655b9639 100644
--- a/android/src/main/res/values/strings.xml
+++ b/android/src/main/res/values/strings.xml
@@ -1,3 +1,6 @@
 <resources>
   <string name="app_name">Descent 3</string>
+    <string name="game_data_upload">Game Data Upload</string>
+  <string name="network_unavailable"><![CDATA[<network unavailable>]]></string>
+  <string name="upload_instructions">Navigate to one of the addresses above (note the port number!) on a computer that has Descent3 installed and is connected to the same WiFi as your Android device.</string>
 </resources>

From 6f02671cb5c8acccab64c270998d8d1dcfff6bb4 Mon Sep 17 00:00:00 2001
From: Chris Sarbora <tophyr@gmail.com>
Date: Mon, 6 Jan 2025 01:17:10 -0600
Subject: [PATCH 10/10] Lock game to landscape mode

Resolves #5
---
 android/src/main/AndroidManifest.xml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/android/src/main/AndroidManifest.xml b/android/src/main/AndroidManifest.xml
index f51bfeb04..4995f147a 100644
--- a/android/src/main/AndroidManifest.xml
+++ b/android/src/main/AndroidManifest.xml
@@ -2,6 +2,7 @@
      com.gamemaker.game
 -->
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  xmlns:tools="http://schemas.android.com/tools"
   android:installLocation="auto"
   android:versionCode="1"
   android:versionName="devel">
@@ -71,11 +72,13 @@
     <activity
       android:name="MainActivity"
       android:alwaysRetainTaskState="true"
+      android:screenOrientation="sensorLandscape"
       android:configChanges="layoutDirection|locale|orientation|uiMode|screenLayout|screenSize|smallestScreenSize|keyboard|keyboardHidden|navigation"
       android:exported="true"
       android:label="@string/app_name"
       android:launchMode="singleInstance"
-      android:preferMinimalPostProcessing="true">
+      android:preferMinimalPostProcessing="true"
+      tools:ignore="DiscouragedApi">
 
       <!-- Let Android know that we can handle some USB devices and should receive this event -->
       <intent-filter>